1 Correct answer
Hello all, here comes the final version.
This time "offset path effect" been used. I thought this is a possible way at beginning, but never give it a try, until today.
It deal with both Path and Compound Path. Test the sample document, it only took 31 seconds.
Explore related tutorials & articles
59
Replies
Thank you, but my skill is not enouth to modify and compute your script with this one. Can you take a look on algoritm? The problem is that script generating sub and sub layers, so your script can work with 1 level layers only.
Look please on script:
#target illustrator
if (app.documents.length > 0)
{
if (app.activeDocument.pageItems.length > 0)
{
var release_to_layers_window; // make window global
var doc = app.activeDocument;
var doc_artboard = doc.artboards[0].artboardRect;
var unlocked_layers_count = 0; // number of unlocked layers in layer palette for progress bar
var msis_message_1 = "\nThis script will place each object within this current document into a new layer based on it's fill color. "+
"As the script currently does not detect locked layers and locked objects you need to unlock your layers and objects before you can run this script. " +
"Note that running this script will modify your document. You might want to save your document first.";
var doc = app.activeDocument;
var Counter = app.activeDocument.pageItems.length;
var LayerName = "";
var ReleaseMethod = 1;
// start dialog window
release_to_layers_dialog();
}
// what if no document of no objects?
if (app.documents.length < 1)
{alert("No open documents found. Please open a document before you run this script");}
if (app.documents.length > 0 && app.activeDocument.pathItems.length < 1)
{alert("No objects found in this documents. Please add some objects before you run this script");}
}
// ********************************************************************************************************
// ** **
// ** find the most common value in an array **
// ** **
// ** http://www.experts-exchange.com/Programming/Languages/Scripting/JavaScript/Q_20871554.html **
// ** var myArray = ["apple","banana","orange","banana","tomato","grape","apple"]; **
// ** alert( GetMostCommonColor(myArray) ); **
// ** **
// ********************************************************************************************************
function GetMostCommonColor(theArray)
{
var tempArray = new Array();
tempArray.length = 0;
tempArray = theArray.slice(0,theArray.length);
tempArray.sort();
tempArray[tempArray.length] = "";
mVal = aVal = "";
mCnt = aCnt = 0;
for(r=0;r<tempArray.length;r++)
{
if(aVal!=tempArray
) {
if(aCnt>mCnt)
{
mCnt = aCnt;
mVal = aVal
}
aVal = tempArray
; aCnt = 1;
} else
{
aCnt++;
}
}
// return [mVal, mCnt]; // returns value and count
return mVal; // only returns value
}
// ********************************************************************************************************
// ** **
// ** create a layer name for the current object **
// ** **
// ********************************************************************************************************
function ConstructLayerNameBasedOnFillColor(myCurrentObject)
{
var myLayerName = "Unknown";
if (myCurrentObject.typename == "TextFrame") { myLayerName = "Text Objects"; }
if (myCurrentObject.typename == "SymbolItem") { myLayerName = "Symbols"; }
if (myCurrentObject.typename == "RasterItem") { myLayerName = "Raster Objects"; }
if (myCurrentObject.typename == "PathItem")
{
if ( myCurrentObject.filled == true )
{
myLayerName = 'Object with unknown Fill Color'; // default name for if no color can be detected
if (myCurrentObject.fillColor == "[CMYKColor]") // CMYK color Item
{
myLayerName = "CMYK: " + Math.round(myCurrentObject.fillColor.cyan) + "," + Math.round(myCurrentObject.fillColor.magenta) + "," + Math.round(myCurrentObject.fillColor.yellow) + "," + Math.round(myCurrentObject.fillColor.black);
}
if (myCurrentObject.fillColor == "[RGBColor]") // RGB color Item
{
myLayerName = "RGB: " + Math.round(myCurrentObject.fillColor.red) + "," + Math.round(myCurrentObject.fillColor.green) + "," + Math.round(myCurrentObject.fillColor.blue);
}
if (myCurrentObject.fillColor == "[GrayColor]") // Gray color Item
{
myLayerName = "Gray: " + Math.round(myCurrentObject.fillColor.gray);
}
if (myCurrentObject.fillColor == "[LabColor]") // LabColor color Item
{
myLayerName = "Lab: " + Math.round(myCurrentObject.fillColor.a) + "," + Math.round(myCurrentObject.fillColor.b) + "," + Math.round(myCurrentObject.fillColor.i);
}
if (myCurrentObject.fillColor == "[GradientColor]") // Gradient color Item
{
myLayerName = "Gradient Fill";
}
if (myCurrentObject.fillColor == "[NoColor]") // No Color Item
{
myLayerName = "No Color";
}
if (myCurrentObject.fillColor == "[PatternColor]") // Pattern Color Item
{
myLayerName = "Pattern Fill";
}
if (myCurrentObject.fillColor == "[SpotColor]") // Spot Color Item
{
// cmyk spot
if (myCurrentObject.fillColor.spot.spotKind == SpotColorKind.SPOTCMYK) // CMYK color Item
{
myLayerName = "Spot CMYK: " + Math.round(myCurrentObject.fillColor.spot.color.cyan) + "," + Math.round(myCurrentObject.fillColor.spot.color.magenta) + "," + Math.round(myCurrentObject.fillColor.spot.color.yellow) + "," + Math.round(myCurrentObject.fillColor.spot.color.black);
}
// rgb spot
if (myCurrentObject.fillColor.spot.spotKind == SpotColorKind.SPOTRGB) // RGB color Item
{
myLayerName = "Spot RGB: " + Math.round(myCurrentObject.fillColor.spot.color.red) + "," + Math.round(myCurrentObject.fillColor.spot.color.green) + "," + Math.round(myCurrentObject.fillColor.spot.color.blue);
}
// lab spot
if (myCurrentObject.fillColor.spot.spotKind == SpotColorKind.SPOTLAB) // RGB color Item
{
myLayerName = "Spot Lab: " + Math.round(myCurrentObject.fillColor.spot.color.a) + "," + Math.round(myCurrentObject.fillColor.spot.color.b) + "," + Math.round(myCurrentObject.fillColor.spot.color.i);
}
}
}
else
{
myLayerName = "Transparant Fill";
}
}
if (myLayerName == undefined) {myLayerName = "Temporary Layer";}
if (myLayerName == "") {myLayerName = "Temporary Layer";}
if (myLayerName.length==0) {myLayerName = "Temporary Layer";}
try
{
doc.layers.getByName(myLayerName);
}
catch (e)
{
doc.layers.add().name = myLayerName;
}
return myLayerName;
}
// ********************************************************************************************************
// ** **
// ** ungroup objects on current layer **
// ** **
// ********************************************************************************************************
function Ungroup(WhereToUngroup, aGroup) // where to ungroup? layer, document, other group?
{
try
{
for (s=aGroup.pageItems.length-1; s>=0; s--)
{
WhereToUngroup = CreateLayerNameFill(myCurrentObject); // ????????? should be something like WhereToUngroup = CreateLayerNameFill(=aGroup.pageItems); // ???????????????????????????
aGroup.pageItems
.move(WhereToUngroup, ElementPlacement.PLACEATBEGINNING);}
}
catch(err)
{
}
}
// ********************************************************************************************************
// ** **
// ** remove layerswith no objects **
// ** **
// ********************************************************************************************************
function RemoveEmptyLayers()
{
var ThisDoc = app.activeDocument;
var ActiveLayer = '';
for (t = ThisDoc.layers.length-1; t>=0; t--)
{
ActiveLayer = ThisDoc.layers
; if (ActiveLayer.pageItems.length == 0)
{
try
{
ActiveLayer.remove();
}
catch(err)
{
}
}
}
}
// ********************************************************************************************************
// ** **
// ** building and showing main dialog **
// ** **
// ********************************************************************************************************
function release_to_layers_dialog() {
// Export dialog
release_to_layers_window = new Window('dialog', 'Release objects to layers based on object fill color');
// PANEL with usage instructions
release_to_layers_window.MessagePanel = release_to_layers_window.add('panel', undefined, 'Release Objects to Layers');
// GROUP
var Message_Group = release_to_layers_window.MessagePanel.add('group', undefined, '')
Message_Group.orientation = 'column';
Message_Group.alignment = [ScriptUI.Alignment.LEFT, ScriptUI.Alignment.TOP]
// Labels
var Message_Group_label_1 = Message_Group.add('statictext', undefined, msis_message_1, {multiline:true});
Message_Group_label_1.size = [500,80];
// PANEL with group and compound path handling
release_to_layers_window.OptionsPanel = release_to_layers_window.add ('panel', undefined, 'Group and Compound Path Items:');
// GROUP
var Radio_Group = release_to_layers_window.OptionsPanel.add('group', undefined, '')
Radio_Group.alignChildren = "left";
Radio_Group.size = [500,65];
Radio_Group.orientation = 'column';
// Radio Boxes
var RadioBox1 = Radio_Group.add ("radiobutton", undefined, "Do not process Group and Compound Path Items.");
var RadioBox2 = Radio_Group.add ("radiobutton", undefined, "Release Groups and Compound Path Items by most common color.");
var RadioBox3 = Radio_Group.add ("radiobutton", undefined, "Ungroup Group and Compound Path Items (caution: might alter shape appearance).");
RadioBox2.value = true;
// PANEL with Progressbar
release_to_layers_window.ProgressPanel = release_to_layers_window.add('panel', undefined, 'Status:');
// GROUP
var Progress_Group = release_to_layers_window.ProgressPanel.add('group', undefined, '')
Progress_Group.orientation = 'column';
Progress_Group.alignment = [ScriptUI.Alignment.LEFT, ScriptUI.Alignment.TOP]
Progress_Group.size = [500,5];
// progressbar
release_to_layers_window.ProgressProgressBar = release_to_layers_window.ProgressPanel.add( 'progressbar', undefined, 0, 100 );
release_to_layers_window.ProgressProgressBar.size = [480,10];
// label
release_to_layers_window.ProgressLabel = release_to_layers_window.ProgressPanel.add('statictext', undefined, 'Found ' + Counter + ' objects in this document.' );
release_to_layers_window.ProgressLabel.size = [ 480,20 ];
// Buttons don't have a PANEL
// GROUP
Button_Group = release_to_layers_window.add('group', undefined, '');
Button_Group.orientation = 'row'
Button_Group.cancelBtn = Button_Group.add('button', undefined, 'Cancel', {name:'cancel'});
Button_Group.cancelBtn.onClick = function() { msis_ai_dlg.close() };
Button_Group.okBtn = Button_Group.add('button', undefined, 'Release', {name:'ok'});
Button_Group.okBtn.onClick = function()
{ Button_Group.okBtn.enabled = false;
Button_Group.cancelBtn.enabled = false;
RadioBox1.enabled = false;
RadioBox2.enabled = false;
RadioBox3.enabled = false;
if (RadioBox1.value == true) {ReleaseMethod = 1;}
if (RadioBox2.value == true) {ReleaseMethod = 2;}
if (RadioBox3.value == true) {ReleaseMethod = 3;}
Process_Objects();
};
release_to_layers_window.show();
}
//var textRef1 = myCurrentObject.textFrames.add();
//textRef1.contents = "1";
// ********************************************************************************************************
// ** **
// ** execute main routine when clicking the Release button **
// ** **
// ********************************************************************************************************
function Process_Objects()
{
// Release to layers but skip Groups and Compound Paths Items OR move groups and compound paths but keep then as group objects
if (ReleaseMethod == 1 || ReleaseMethod == 2)
{
for ( i=0; i < Counter; i++ ) //123
{
LayerName = "0";
try
{
CurrentItem = doc.pageItems;
if (CurrentItem.typename != "GroupItem" && CurrentItem.typename != "CompoundPathItem" && CurrentItem.parent.typename != "GroupItem" && CurrentItem.parent.typename != "CompoundPathItem") // no need to create layers for objects within grouped items
{
LayerName = ConstructLayerNameBasedOnFillColor(CurrentItem);
CurrentItem.move( app.activeDocument.layers.getByName( LayerName ), ElementPlacement.PLACEATBEGINNING );
}
} // try
catch(err)
{ // except
alert("An error occured processing objects.\n(" + err + ").\n\nFunction: Process_Objects / method=1.");
} // except
release_to_layers_window.ProgressLabel.text = 'Processed ' + i + ' objects out of ' + Counter + ' objects in total.';
release_to_layers_window.ProgressProgressBar.value = (100 / Counter) * i;
release_to_layers_window.update();
} // for
} // end method 1
// Release to layers, move Group and Compound Path Items based on most common fill color
if (ReleaseMethod == 2)
{
// first move all group objects
LayerName = "0";
for ( j=0; j < doc.groupItems.length; j++ )
{
var CurrentGroupItem = doc.groupItems
; var MyArray = new Array;
var TempLayerName = "";
for (m = CurrentGroupItem.pageItems.length-1; m>=0; m--)
{
TempLayerName = ConstructLayerNameBasedOnFillColor( CurrentGroupItem.pageItems
); MyArray.push( TempLayerName );
}
LayerName = GetMostCommonColor(MyArray);
CurrentGroupItem.moveToBeginning(app.activeDocument.layers.getByName( LayerName ) );
release_to_layers_window.ProgressLabel.text = 'Processed ' + j + ' group objects out of ' + Counter + ' objects in total.';
release_to_layers_window.ProgressProgressBar.value = (100 / Counter) * j;
release_to_layers_window.update();
}
// next move all compound path objects
LayerName = "0";
for ( j=0; j < doc.compoundPathItems.length; j++ )
{
var CurrentCompoundItem = doc.compoundPathItems
; var MyArray = new Array;
var TempLayerName = "";
for (m = CurrentCompoundItem.pathItems.length-1; m>=0; m--)
{
TempLayerName = ConstructLayerNameBasedOnFillColor( CurrentCompoundItem.pathItems
); MyArray.push( TempLayerName );
}
LayerName = GetMostCommonColor(MyArray);
CurrentCompoundItem.moveToBeginning(app.activeDocument.layers.getByName( LayerName ) );
release_to_layers_window.ProgressLabel.text = 'Processed ' + j + ' group objects out of ' + Counter + ' objects in total.';
release_to_layers_window.ProgressProgressBar.value = (100 / Counter) * j;
release_to_layers_window.update();
}
}
// Release to layers and ungroup Group and Compound Path Items
if (ReleaseMethod == 3)
{
for ( k=0; k < Counter; k++ ) //123
{
LayerName = "0";
try
{
CurrentItem = doc.pageItems
; LayerName = ConstructLayerNameBasedOnFillColor(CurrentItem);
if (CurrentItem.typename != "GroupItem" && CurrentItem.typename != "CompoundPathItem") // no need to create layers for objects within grouped items
{
CurrentItem.move( app.activeDocument.layers.getByName( LayerName ), ElementPlacement.PLACEATBEGINNING );
} // try
else
{
UnGroupLayer = app.activeDocument.layers.getByName( LayerName );
Ungroup( UnGroupLayer , CurrentItem );
}
}
catch(err)
{ // except
alert("An error occured processing objects.\n(" + err + ").\n\nFunction: Process_Objects / method=3.");
} // except
release_to_layers_window.ProgressLabel.text = 'Processed ' + k + ' objects out of ' + Counter + ' objects in total.';
release_to_layers_window.ProgressProgressBar.value = (100 / Counter) * k;
release_to_layers_window.update();
} // for
} // end methode 3
RemoveEmptyLayers();
release_to_layers_dialog.close();
}
Nice looking script, but not sure its doing the correct thing.
in this image the black dot is produced by this script.
the blue scribble is where I would expect the point to land.
here is the working example I came up with.
it runs too slow but is way more reliable then the create action method.
I added a timer so you can see the run time.
on my sample file (12 shapes) it took 5 - 10 seconds to run.
THIS WILL RUN SLOW!!!
function add_nums(){
// fiddle with these values to adjust speed vs accuracy
var percentage = 1; // take average betwenn hight and width and multiplies it by this to get starting stroke weight - 1 = 100%
var increment = .8; // amount to add to percentage on each iteration
var doc = app.activeDocument;
var lays = doc.layers;
var layNames = [];
for(var i=0; i<lays.length; i++){
layNames.push(lays.name);
}
// new layers
var WORK_LAY = doc.layers.add();
WORK_LAY.name = "Working Layer";
var NUM_LAY = doc.layers.add();
NUM_LAY.name = "Numbers";
// main working loop
for(var i=0; i<layNames.length; i++){
//process each layer
var lay = lays.getByName(layNames);
lay.name = lay.name + " Num:" + (i+1);
for(var j=0; j<lay.pathItems.length; j++){
// process each pathItem
var pth = lay.pathItems
; var per = percentage; // reset the path percentage for each shape
var cent = [];
var Count = 0;
if(FatPart(pth) === "error"){
alert("Loop Error, try resetting\npercentage to 1,\nand\nincroment to .8\nin the script file");
return;
}
// Create the text frame
var txt = NUM_LAY.textFrames.add();
txt.contents = i+1;
txt.textRange.justification = Justification.CENTER;
txt.position = [cent[0]-txt.width/2,cent[1]+txt.height/2];
pth.filled = false;
pth.stroked = true;
}
}
//clean up
WORK_LAY.remove();
// find fat section of a shape
function FatPart(pth){
var success = false;
while(!success){
success = process();
// if recursive function runs too many times give option to exit
Count++;
if(Count%100 === 0){
var keepGoing = confirm("Process function has run " + Count + " times on current object.\nWould you like to continue trying?");
if(!keepGoing){
return "error";
}
}
}
function process(){
// make sure we start with nothing selected
doc.selection = null;
// make a copy of the shape to work on
var item = pth.duplicate(WORK_LAY,ElementPlacement.PLACEATBEGINNING);
item.filled = false;
item.stroked = true;
// scale works out how thick the stroke shold be
var scale = ((item.height+item.width)/20)*per;
item.strokeWidth = scale;
// select the items and outline the stroke
item.selected = true;
app.executeMenuCommand ('OffsetPath v22');// = Outline Stroke
var sel = doc.selection;
if(sel[0].typename === "CompoundPathItem"){
if(sel[0].pathItems.length>2){
// too many paths, increase stroke and retry
sel[0].remove()
per = per + increment;
return false;
}else{
// Remove the larger of the 2 shapes in the compoundPath
if(Math.abs(sel[0].pathItems[0].area)>Math.abs(sel[0].pathItems[1].area)){
sel[0].pathItems[0].remove();
}else{
sel[0].pathItems[1].remove();
}
// compare size against original - Aiming for under 10%
if(Math.abs(sel[0].pathItems[0].area)>Math.abs(item.area)/10){ // the 10 is ten percent of original size
sel[0].pathItems[0].remove();
per = per + increment;
return false;
}else{
// now we should have correct size to center text to
// return X,Y of shapes Center
var B = sel[0].geometricBounds;
cent.push(B[0]+(B[2]-B[0])/2);
cent.push(B[1]+(B[3]-B[1])/2);
sel[0].remove()
return true;
}
}
}else{
// shape filled completely, reduced stroke and retry
sel[0].remove()
per = per - increment/10;
return false;
}
}
}
}
var timer = Date.now();
add_nums();
var x = (Date.now()-timer);
alert('conversion completed in:\n'
+ Math.floor(x/1000/60) + ' Minutes, '
+ Math.floor(x/1000%60) + ' Seconds, and '
+ x%1000 + ' Milliseconds');
AdChoices