How to move the ends of the lines slanted towards the limits of the purge

Hi all

I developed a script that deletes the page elements to the purge. To achieve this, that I collect all the elements of the page (with the exception of text blocks) located partially on the editing table, create a temporary mask and 'trim' with subtraction of Pathfinder function. However, this approach does not work with graphic lines so I'm trying to move the ends of the lines to the limits of the substantive area lost. (I guess these are simple straight lines consisting of two end points).

I knew how to deal with orthogonal lines - it's pretty easy:

if (theItem.constructor.name == "GraphicLine" && theItem.paths.length === 1) {
     path = theItem.paths[0];
     if (path.pathPoints.length === 2) {
          ep = path.entirePath;
          w = ep[1][0]-ep[0][0];
          h = ep[1][1]-ep[0 ][1];
          
          if (w > h) {
               newEp = [ [ spreadWithBleedBounds[1], ep[0][1] ], [ spreadWithBleedBounds[3], ep[1][1] ] ];
               path.entirePath = newEp;
          }
          else if (h > w) {
               newEp = [ [ ep[0][0], spreadWithBleedBounds[0] ], [ ep[1][0], spreadWithBleedBounds[2] ] ];
               path.entirePath = newEp;
          }
     }
}

This moves A1 - A2, B1 , B2, C1 , C2, D1 to D2.

But how to treat skewed lines? How to calculate the coordinates of the point E2 and F2? Y at - it a magic formula? Or can someone point me to the right direction: for example a book to read?

I assume this has something to do with geometry/trigonometry, but I haven't studied this kind of things at school. (I graduated from an art school - designed to draw naked models instead).

If someone will answer my question, please do it on basic level since I'm a total noob in the present.

Here's the script:

if (Number(String(app.version).split(".")[0]) == 7) ErrorExit("This script can't work with InDesign CS5 so far.", true);

var doc = app.activeDocument;
var spreadBounds, spreadWithBleedBounds, gPartiallyOutOfSpreadItems;
var ungroupErrors = 0;

var originalHorUnits =  doc.viewPreferences.horizontalMeasurementUnits;
var originalVerUnits =  doc.viewPreferences.verticalMeasurementUnits;
doc.viewPreferences.horizontalMeasurementUnits = doc.viewPreferences.verticalMeasurementUnits = MeasurementUnits.INCHES;
doc.viewPreferences.rulerOrigin = RulerOrigin.spreadOrigin;
doc.zeroPoint = [0, 0];

if (doc.layers.itemByName("Temporary Layer") == null ) {
     var tempLayer = doc.layers.add({name:"Temporary Layer"});
}
else {
     var tempLayer = doc.layers.itemByName("Temporary Layer");
}

UngroupAllGroups(doc.groups);

DeleteObjectsOnPasteboard();
ProcessSpreads(doc.spreads);
ProcessSpreads(doc.masterSpreads);

tempLayer.remove();

doc.viewPreferences.horizontalMeasurementUnits = originalHorUnits;
doc.viewPreferences.verticalMeasurementUnits = originalVerUnits;

var msg = (ungroupErrors > 0) ? " Failed to ungroup " + ungroupErrors + " groups since they are too large." : "";
alert("Done." + msg, "Trim Pages Script");

//================================== FUNCTONS ===========================================
function ProcessSpreads(spreads) {
     var spread, path, ep, w, h;
     for (var s = 0; s < spreads.length; s++) {
          spread = spreads[s];
          spreadBounds = GetSpreadBound(spread, false);
          spreadWithBleedBounds = GetSpreadBound(spread, true);
          
          gPartiallyOutOfSpreadItems = GetPartiallyOutOfSpreadItems(spread);
          
          var theItem, theMask, newItem;
          for (var i = gPartiallyOutOfSpreadItems.length-1; i >= 0; i--) {
               theItem = gPartiallyOutOfSpreadItems[i];
               if (theItem.constructor.name == "GraphicLine" && theItem.paths.length === 1) {
                    path = theItem.paths[0];
                    if (path.pathPoints.length === 2) {
                         ep = path.entirePath;
                         w = ep[1][0]-ep[0][0];
                         h = ep[1][1]-ep[0 ][1];
                         
                         if (w > h) {
                              newEp = [ [ spreadWithBleedBounds[1], ep[0][1] ], [ spreadWithBleedBounds[3], ep[1][1] ] ];
                              path.entirePath = newEp;
                         }
                         else if (h > w) {
                              newEp = [ [ ep[0][0], spreadWithBleedBounds[0] ], [ ep[1][0], spreadWithBleedBounds[2] ] ];
                              path.entirePath = newEp;
                         }
                    }
               }
               else {
                    theMask = CreateMask(spread);
                    try {
                         newItem = theMask.subtractPath(theItem);
                    }
                    catch (err) {
                         $.writeln("2 - " + err);
                         theMask.remove();
                    }
               }
          }
     }
}
//--------------------------------------------------------------------------------------------------------------
function IsPartiallyOutOfSpread(pageItem) {
     var result = false;
     if (pageItem.constructor.name == "TextFrame" ||
          pageItem.constructor.name == "Group" ||
          pageItem.parent.constructor.name == "Group")
     {
          return result;
     }

     var visBounds = pageItem.visibleBounds;
     if (visBounds[0] < spreadBounds[0] && visBounds[2] > spreadBounds[0] ||
          visBounds[1] < spreadBounds[1] && visBounds[3] > spreadBounds[1] ||
          visBounds[2] > spreadBounds[2] && visBounds[0] < spreadBounds[2] ||
          visBounds[3] > spreadBounds[3] && visBounds[1] < spreadBounds[3]  ) {
          result = true;
     }
     return result;
}
//--------------------------------------------------------------------------------------------------------------
function GetSpreadBound(spread, bleed) { // including bleed -boolean
     if (bleed == undefined) bleed = false;
     
     with (doc.documentPreferences) {
          var topBleed = documentBleedTopOffset
          var leftBleed = documentBleedInsideOrLeftOffset;
          var bottomBleed = documentBleedBottomOffset;
          var rightBleed = documentBleedOutsideOrRightOffset;
     }

     var bFirst = spread.pages.item(0).bounds; // bounds of the first page
     var bLast = spread.pages.item(-1).bounds; // bounds of the last page
     return [     ((bleed) ? bFirst[0]-topBleed : bFirst[0]), 
                    ((bleed) ? bFirst[1]-leftBleed : bFirst[1]), 
                    ((bleed) ? bLast[2]+bottomBleed : bFirst[2]), 
                    ((bleed) ? bLast[3]+rightBleed : bLast[3])
                    ];
}
//--------------------------------------------------------------------------------------------------------------
function CreateMask(spread) {
     var unitValue = new UnitValue (app.pasteboardPreferences.minimumSpaceAboveAndBelow, "mm");
     var unitValueAsInch = unitValue.as("in");
     var outerRectangleBounds = [spreadWithBleedBounds[0]-unitValueAsInch, 
                                                            spreadWithBleedBounds[1]-8.07, 
                                                            spreadWithBleedBounds[2]+unitValueAsInch, 
                                                            spreadWithBleedBounds[3]+8.07
                                                            ]; 

     var outerRectangle = spread.rectangles.add(tempLayer, undefined, undefined, {geometricBounds:outerRectangleBounds});
     var innerRectangle = spread.rectangles.add(tempLayer, undefined, undefined, {geometricBounds:spreadWithBleedBounds, fillColor:doc.swatches.item("Black"), fillTint:30});
     var mask = outerRectangle.excludeOverlapPath(innerRectangle);
     return mask;
}
//--------------------------------------------------------------------------------------------------------------
function GetPartiallyOutOfSpreadItems(spread) {
     var allPageItems = spread.allPageItems;
     var partiallyOutOfSpreadItems = [];
     var currentItem;
     
     for (var i = 0; i < allPageItems.length; i++) {
          currentItem = allPageItems[i];
          if (IsPartiallyOutOfSpread(currentItem)) partiallyOutOfSpreadItems.push(currentItem);
     }
     
     return partiallyOutOfSpreadItems;
}
//--------------------------------------------------------------------------------------------------------------
function DeleteObjectsOnPasteboard() {
     var objs = app.documents[0].pageItems.everyItem().getElements();
     while (obj=objs.pop()) {
          try {
               if(obj.parent instanceof Spread || obj.parent instanceof MasterSpread){ obj.remove() }
          }
          catch(err) {
               //$.writeln("2 - " + err);
          }
     }
}
//--------------------------------------------------------------------------------------------------------------
function ErrorExit(myMessage, myIcon) {
     alert(myMessage, "Trim Pages Script", myIcon);
     exit();
}
//--------------------------------------------------------------------------------------------------------------
function UngroupAllGroups(groups) {
     for (var i = groups.length-1; i >= 0; i--) {
          var gr = groups[i];
          if (gr.groups.length > 0) {
               var subGroups = [];
               for (var j = gr.groups.length-1; j >= 0; j--) {
                    subGroups.push(gr.groups[j].id);
               }                    
               try {
                    gr.ungroup();
               }
               catch(err) {
                    //$.writeln("1 - " + err);
                    ungroupErrors++;
               }
          
               for (var k = subGroups.length-1; k >= 0; k--) {
                    try {
                         doc.groups.itemByID(subGroups[k]).ungroup();
                    }
                    catch(err) {
                         //$.writeln("2 - " + err);
                         ungroupErrors++;
                    }
               }
          }
          else {
               try {
                    gr.ungroup();
               }
               catch(err) {
                    //$.writeln("1 - " + err);
                    ungroupErrors++;
               }
          }
     }     
}
//--------------------------------------------------------------------------------------------------------------

Thanks in advance.

Kasyan

Hi Kasyan!

I was not trying to integrate this into your script, so you may need to adjust a little. The trick is to define a function that detects the point of intersection of two lines - and, of course, you must call it for lines that will not fail to cross the border of the page! (Otherwise, it would simply expand * any * the line upward and on the border.)

I think it would be wise to predict a small mistake for lines that seem to run "up to" the edge of the page - I tested a line for 'x '.<= 0"="" on="" a="" line="" that="" appeared="" to="" start="" on="" 0;="" the="" control="" panel="" told="" me="" so.="" however,="" i="" didn't="" type="" that="" 0="" in;="" i="" dragged="" the="" line="" to="" the="" edge.="" apparently,="" it="" was="" *not*="" at="" precisely="" "0mm",="" but="" something="" like="" "0.001mm",="" because="" the="" script="" simply="" didn't="" "see"="" the="">

My function comes from this page: http://local.wasp.uwa.edu.au/~pbourke/geometry/lineline2d/ and I did not test it does of orthogonal lines

(but of course, you could add this in exceptional cases), and it's my script extending the line, with a small wrapper to configure things.

The function tests * any * tail against * any * other line, so if we meet the page bounding box, I get the intersection with the purge of the side area where it crosses the bbox page.

line = app.selection[0];
// pg size in "regular" [y1,x1, y2,x2] format
pagebbox = [0,0, app.activeDocument.documentPreferences.pageHeight,app.activeDocument.documentPreferences.pageWidth ];
bleedDist = 5; //
bleedbbox = [ pagebbox[0] - bleedDist, pagebbox[1] - bleedDist, pagebbox[2] + bleedDist, pagebbox[3] + bleedDist ];
pt1 = line.paths[0].pathPoints[0].anchor;
pt2 = line.paths[0].pathPoints.lastItem().anchor;
// Start point:
if (pt1[0] <= pagebbox[1] || pt1[0] >= pagebbox[3] ||
 pt1[1] <= pagebbox[0] || pt1[1] >= pagebbox[2])
{
 if (pt1[0] <= pagebbox[1])
  intersectPt = IntersectionPt ( [pt1, pt2], [ [ bleedbbox[1], bleedbbox[0]], [bleedbbox[1], bleedbbox[2] ] ] );

 if (pt1[0] >= pagebbox[3])
  intersectPt = IntersectionPt ( [pt1, pt2], [ [ bleedbbox[3], bleedbbox[0]], [bleedbbox[3], bleedbbox[2] ] ] );

 if (pt1[1] <= pagebbox[0])
  intersectPt = IntersectionPt ( [pt1, pt2], [ [ bleedbbox[1], bleedbbox[0]], [bleedbbox[3], bleedbbox[0] ] ] );
 if (pt1[1] >= pagebbox[2])
  intersectPt = IntersectionPt ( [pt1, pt2], [ [ bleedbbox[1], bleedbbox[2]], [bleedbbox[3], bleedbbox[2] ] ] );
 line.paths[0].pathPoints[0].anchor = intersectPt;
}
// End point:
if (pt2[0] <= pagebbox[1] || pt2[0] >= pagebbox[3] ||
 pt2[1] <= pagebbox[0] || pt2[1] >= pagebbox[2])
{
 if (pt2[0] <= pagebbox[1])
  intersectPt = IntersectionPt ( [pt1, pt2], [ [ bleedbbox[1], bleedbbox[0]], [bleedbbox[1], bleedbbox[2] ] ] );

 if (pt2[0] >= pagebbox[3])
  intersectPt = IntersectionPt ( [pt1, pt2], [ [ bleedbbox[3], bleedbbox[0]], [bleedbbox[3], bleedbbox[2] ] ] );

 if (pt2[1] <= pagebbox[0])
  intersectPt = IntersectionPt ( [pt1, pt2], [ [ bleedbbox[1], bleedbbox[0]], [bleedbbox[3], bleedbbox[0] ] ] );
 if (pt2[1] >= pagebbox[2])
  intersectPt = IntersectionPt ( [pt1, pt2], [ [ bleedbbox[1], bleedbbox[2]], [bleedbbox[3], bleedbbox[2] ] ] );
 line.paths[0].pathPoints.lastItem().anchor = intersectPt;
}

function IntersectionPt (ln1, ln2)
{
 var ua;
 var x1 = ln1[0][0], x2 = ln1[1][0], x3 = ln2[0][0], x4 = ln2[1][0];
 var y1 = ln1[0][1], y2 = ln1[1][1], y3 = ln2[0][1], y4 = ln2[1][1];
 ua = ((x4 - x3)*(y1 - y3) - (y4 - y3)*(x1 - x3))/((y4 - y3)*(x2 - x1) - (x4 - x3)*(y2 - y1));

 return [ x1 + ua*(x2-x1), y1 + ua*(y2-y1) ];
}

Tags: InDesign

How to move the ends of the lines slanted towards the limits of the purge

Similar Questions

Maybe you are looking for