4 Replies Latest reply on Jun 7, 2018 12:05 PM by SuperMerlin

    Get the local space of the guide lines

    i73 Level 1

      I'm trying to access the guide line positions in my document (ctr-r to bring up the ruler, and drag the line out to the spot you want), and wondering how to access the position of them through code (and if I can directly get the intersection in the document in local positions related to a x y coord in the document)

       

      Example of what I mean:

      Screenshot_167.png

       

      Thanks!

        • 1. Re: Get the local space of the guide lines
          JJMack Most Valuable Participant

          See if reading this script helps any.

           

          /* ==========================================================
          // 2014  John J. McAssey (JJMack) 
          // ======================================================= */
          
          
          // This script is supplied as is. It is provided as freeware. 
          // The author accepts no liability for any problems arising from its use.
          
          
          /* Help Category note tag menu can be used to place script in automate menu
          <javascriptresource>
          <about>$$$/JavaScripts/FitImageToGuides/About=JJMack's FitImageToGuides .^r^rCopyright 2014 Mouseprints.^r^rFour and only four guides are required</about>
          <category>JJMack's Script</category>
          </javascriptresource>
          */
          
          
          // enable double-clicking from Mac Finder or Windows Explorer
          #target photoshop // this command only works in Photoshop CS2 and higher
          
          
          // bring application forward for double-click events
          app.bringToFront();
          
          
          // ensure at least one document open
          if (!documents.length) alert('There are no documents open.', 'No Document');
          else {
          // declare Global variables
          
          
          //main(); // at least one document exists proceed
          app.activeDocument.suspendHistory('Fix Image to Guides','main()');  //problem if there is a selection a layer resize Photoshop back up a history step ?
          }
          ///////////////////////////////////////////////////////////////////////////////
          //                            main function                             
          ///////////////////////////////////////////////////////////////////////////////
          function main() {
          // declare local variables
          var orig_ruler_units = app.preferences.rulerUnits;
          var orig_type_units = app.preferences.typeUnits;
          var orig_display_dialogs = app.displayDialogs;
          app.preferences.rulerUnits = Units.PIXELS; // Set the ruler units to PIXELS
          app.preferences.typeUnits = TypeUnits.POINTS;   // Set Type units to POINTS
          app.displayDialogs = DialogModes.NO; // Set Dialogs off
          try { code(); }
          // display error message if something goes wrong
          catch(e) { alert(e + ': on line ' + e.line, 'Script Error', true); }
          app.displayDialogs = orig_display_dialogs; // Reset display dialogs 
          app.preferences.typeUnits  = orig_type_units; // Reset ruler units to original settings 
          app.preferences.rulerUnits = orig_ruler_units; // Reset units to original settings
          }
          ///////////////////////////////////////////////////////////////////////////////
          //                           main function end                            
          ///////////////////////////////////////////////////////////////////////////////
          
          
          ///////////////////////////////////////////////////////////////////////////////////////////////
          // The real code is embedded into this function so that at any point it can return 
          // to the main line function to let it restore users edit environment and end      
          //////////////////////////////////////////////////////////////////////////////////////////////
          function code() {
          if (app.activeDocument.guides.length != 4) { alert("Four and only four Guides are required"); return; } // quit
          // get guides;
          var theVert = new Array;
          var theHor = new Array;
          for (var m = 0; m < app.activeDocument.guides.length; m++) {
          if (app.activeDocument.guides[m].direction == Direction.HORIZONTAL) {theVert.push(app.activeDocument.guides[m].coordinate)}
          else {theHor.push(app.activeDocument.guides[m].coordinate)}
              };
          if (theHor.length != 2 || theVert.length != 2) { alert("Four Guides two vertical and two horizontal are required"); return; } // quit
          getTarget=getSelectedLayersIdx();
          if (getTarget.length!=1){ alert("The number of layers targeted is " + getTarget.length ); return; } // quit
          if (app.activeDocument.activeLayer.isBackgroundLayer ) { alert("Can not resize the background layer"); return; } // quit
          if (!app.activeDocument.activeLayer.visible ) { alert("Active layer is  not visible"); return; } // quit
          //if (hasLayerMask()) { alert("Active layer is  Masked"); return; } // quit
          if (app.activeDocument.activeLayer.kind == LayerKind.NORMAL  || app.activeDocument.activeLayer.kind == LayerKind.SMARTOBJECT && hasLayerMask()) { deleteLayerMask ();}
          if (app.activeDocument.activeLayer.kind != LayerKind.NORMAL  && app.activeDocument.activeLayer.kind != LayerKind.SMARTOBJECT )  { 
          alert("Active layer is " + app.activeDocument.activeLayer.kind); return; } // quit
          // set selection to the area defined but the guide lines the selection may get undone by the bug in .resize() backing up a step in histoty ???
          app.activeDocument.selection.select([[theHor[0], theVert[0]], [theHor[1], theVert[0]], [theHor[1], theVert[1]], [theHor[0], theVert[1]]]);
          // resize current normal layer or smart object layer to just cover selection canvas area aspect ratio and size and mask off any overflow
          var SB = app.activeDocument.selection.bounds; // Get selection bounds
          var SWidth = (SB[2].value) - (SB[0].value); // Area width
          var SHeight = (SB[3].value) - (SB[1].value); // Area height
          var LB = app.activeDocument.activeLayer.bounds; // Get Active layers bounds
          var LWidth = (LB[2].value) - (LB[0].value); // Area width
          var LHeight = (LB[3].value) - (LB[1].value); // Area height
          var userResampleMethod = app.preferences.interpolation; // Save interpolation settings
          app.preferences.interpolation = ResampleMethod.BICUBIC; // resample interpolation bicubic
          app.activeDocument.selection.deselect(); // This deselect work around Adobe Bug in CS5, CS6, CC and CC 2014
          // Since Adobe does not fix old releases of Photoshop this is a necessary work around for many releases of Photoshop
          //alert("Before re-size history");  // Added to debug Adobe Resize Bug
          try {
          if (LWidth/LHeight<SWidth/SHeight) { // layer's Aspect Ratio less the Canvas area Aspect Ratio 
          var percentageChange = ((SWidth/LWidth)*100); // Resize to canvas area width
          app.activeDocument.activeLayer.resize(percentageChange,percentageChange,AnchorPosition.MIDDLECENTER);
          }
          else { 
          var percentageChange = ((SHeight/LHeight)*100); // resize to canvas area height
          app.activeDocument.activeLayer.resize(percentageChange,percentageChange,AnchorPosition.MIDDLECENTER);
          }
          }
          catch(e) { 
          app.preferences.interpolation = userResampleMethod; // Reset interpolation setting
          selectFront(); // Photoshop make top layer current when none are targeted
          code(); // Retry  with top visible layer selected targeted 
          return; // rest would have been done during the retry
          }
          //alert("After re-size history");    // Added to debug Adobe Resize Bug
          app.preferences.interpolation = userResampleMethod; // Reset interpolation setting
          // Seems to be a bug in  resize() the document seems to first be backed up a step in history
          app.activeDocument.selection.select([[theHor[0], theVert[0]], [theHor[1], theVert[0]], [theHor[1], theVert[1]], [theHor[0], theVert[1]]]); // redo the selection
          align('AdCH'); // align to horizontal centers
          align('AdCV'); // align to vertical centers
          addLayermask(); // add layer mask to mask off excess
          }
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          // Helper Functions
          /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
          function align(method) {
          var desc = new ActionDescriptor();
          var ref = new ActionReference();
          ref.putEnumerated( charIDToTypeID( "Lyr " ), charIDToTypeID( "Ordn" ), charIDToTypeID( "Trgt" ) );
          desc.putReference( charIDToTypeID( "null" ), ref );
          desc.putEnumerated( charIDToTypeID( "Usng" ), charIDToTypeID( "ADSt" ), charIDToTypeID( method ) );
          try{executeAction( charIDToTypeID( "Algn" ), desc, DialogModes.NO );}
          catch(e){}
          }
          ///////////////////////////////////////////////////////////////////////////////   
          // Function: hasLayerMask   
          // Usage: see if there is a raster layer mask   
          // Input: <none> Must have an open document   
          // Return: true if there is a vector mask   
          ///////////////////////////////////////////////////////////////////////////////   
          function hasLayerMask() {   
          var hasLayerMask = false;   
          try {   
          var ref = new ActionReference();   
          var keyUserMaskEnabled = app.charIDToTypeID( 'UsrM' );   
          ref.putProperty( app.charIDToTypeID( 'Prpr' ), keyUserMaskEnabled );   
          ref.putEnumerated( app.charIDToTypeID( 'Lyr ' ), app.charIDToTypeID( 'Ordn' ), app.charIDToTypeID( 'Trgt' ) );   
          var desc = executeActionGet( ref );   
          if ( desc.hasKey( keyUserMaskEnabled ) ) { hasLayerMask = true; }   
          }
          catch(e) { hasLayerMask = false; }   
          return hasLayerMask;   
          }   
          function getSelectedLayersIdx(){
                var selectedLayers = new Array;
                var ref = new ActionReference();
                ref.putEnumerated( charIDToTypeID("Dcmn"), charIDToTypeID("Ordn"), charIDToTypeID("Trgt") );
                var desc = executeActionGet(ref);
                if( desc.hasKey( stringIDToTypeID( 'targetLayers' ) ) ){
                   desc = desc.getList( stringIDToTypeID( 'targetLayers' ));
                    var c = desc.count
                    var selectedLayers = new Array();
                    for(var i=0;i<c;i++){
                      try{
                         activeDocument.backgroundLayer;
                         selectedLayers.push(  desc.getReference( i ).getIndex() );
                      }catch(e){
                         selectedLayers.push(  desc.getReference( i ).getIndex()+1 );
                      }
                    }
                 }else{
                   var ref = new ActionReference();
                   ref.putProperty( charIDToTypeID("Prpr") , charIDToTypeID( "ItmI" ));
                   ref.putEnumerated( charIDToTypeID("Lyr "), charIDToTypeID("Ordn"), charIDToTypeID("Trgt") );
                   try{
                      activeDocument.backgroundLayer;
                      selectedLayers.push( executeActionGet(ref).getInteger(charIDToTypeID( "ItmI" ))-1);
                   }catch(e){
                      selectedLayers.push( executeActionGet(ref).getInteger(charIDToTypeID( "ItmI" )));
                   }
                }
                return selectedLayers;
          };
          function selectFront() {
          // Alt+. shortcut select ftont visible layer
          var idslct = charIDToTypeID( "slct" );
              var desc250 = new ActionDescriptor();
              var idnull = charIDToTypeID( "null" );
                  var ref207 = new ActionReference();
                  var idLyr = charIDToTypeID( "Lyr " );
                  var idOrdn = charIDToTypeID( "Ordn" );
                  var idFrnt = charIDToTypeID( "Frnt" );
                  ref207.putEnumerated( idLyr, idOrdn, idFrnt );
              desc250.putReference( idnull, ref207 );
              var idMkVs = charIDToTypeID( "MkVs" );
              desc250.putBoolean( idMkVs, false );
          executeAction( idslct, desc250, DialogModes.NO );
          }
          function deleteLayerMask (apply) {
          // Delet Layer mask default to not apply first
          if (apply == undefined) {var apply = false};
          try {
          var idDlt = charIDToTypeID( "Dlt " );
              var desc9 = new ActionDescriptor();
              var idnull = charIDToTypeID( "null" );
                  var ref5 = new ActionReference();
                  var idChnl = charIDToTypeID( "Chnl" );
                  var idChnl = charIDToTypeID( "Chnl" );
                  var idMsk = charIDToTypeID( "Msk " );
                  ref5.putEnumerated( idChnl, idChnl, idMsk );
              desc9.putReference( idnull, ref5 );
              var idAply = charIDToTypeID( "Aply" );
              desc9.putBoolean( idAply, apply );
          executeAction( idDlt, desc9, DialogModes.NO );
          }
          catch (e) {}
          };
          function addLayermask(){
          // Add layer Mask
          var idMk = charIDToTypeID( "Mk  " );
              var desc52 = new ActionDescriptor();
              var idNw = charIDToTypeID( "Nw  " );
              var idChnl = charIDToTypeID( "Chnl" );
              desc52.putClass( idNw, idChnl );
              var idAt = charIDToTypeID( "At  " );
                  var ref19 = new ActionReference();
                  var idChnl = charIDToTypeID( "Chnl" );
                  var idChnl = charIDToTypeID( "Chnl" );
                  var idMsk = charIDToTypeID( "Msk " );
                  ref19.putEnumerated( idChnl, idChnl, idMsk );
              desc52.putReference( idAt, ref19 );
              var idUsng = charIDToTypeID( "Usng" );
              var idUsrM = charIDToTypeID( "UsrM" );
              var idRvlS = charIDToTypeID( "RvlS" );
              desc52.putEnumerated( idUsng, idUsrM, idRvlS );
          executeAction( idMk, desc52, DialogModes.NO );
          // Un link layer mask just added fron the layers content
          var idsetd = charIDToTypeID( "setd" );
              var desc2 = new ActionDescriptor();
              var idnull = charIDToTypeID( "null" );
                  var ref1 = new ActionReference();
                  var idLyr = charIDToTypeID( "Lyr " );
                  var idOrdn = charIDToTypeID( "Ordn" );
                  var idTrgt = charIDToTypeID( "Trgt" );
                  ref1.putEnumerated( idLyr, idOrdn, idTrgt );
              desc2.putReference( idnull, ref1 );
              var idT = charIDToTypeID( "T   " );
                  var desc3 = new ActionDescriptor();
                  var idUsrs = charIDToTypeID( "Usrs" );
                  desc3.putBoolean( idUsrs, false );
              var idLyr = charIDToTypeID( "Lyr " );
              desc2.putObject( idT, idLyr, desc3 );
          executeAction( idsetd, desc2, DialogModes.NO );
          }
          
          • 2. Re: Get the local space of the guide lines
            SuperMerlin Level 5

            I can only find a way by using DOM.

            //Requires Photoshop CS5 or newer
            #target photoshop;
            
            var guides = app.activeDocument.guides;
            var X,Y;
            
            if(guides.length == 2){
                if(guides[0].direction == "Direction.VERTICAL"){
                    X = guides[0].coordinate.value;
                    }else{
                        Y = guides[0].coordinate.value;
                        }
                if(guides[1].direction == "Direction.VERTICAL"){
                    X = guides[1].coordinate.value;
                    }else{
                        Y = guides[1].coordinate.value;
                        }
                    alert("X = " + X.toFixed(0) + " Y = " + Y.toFixed(0));
            }
            
            
            
            
            1 person found this helpful
            • 3. Re: Get the local space of the guide lines
              bena10018036 Level 1

              Guides are an array so if it's the first guide you placed "i" should be 0. If it's the 2nd you placed. "i" should be 1.

               

              A guide has 2 variables you can get.

              app.activeDocument.guides[i].direction

              app.activeDocument.guides[i].coordinate

               

              the direction outputs "direction.VERTICAL" or "direction.HORIZONTAL".

              The coordinate is the X or Y position, depending on what the direction is.

               

              the intersecting position you seek is basicly just the 2 coordinates together.

               

              //If the vertical guide is the 1st placed guide
              var intersectingPositionX = app.activeDocument.guides[0].coordinate 
              var intersectingPositionY app.activeDocument.guides[1].coordinate
              
              //Otherwise its this
              //var intersectingPositionY = app.activeDocument.guides[0].coordinate 
              //var intersectingPositionX app.activeDocument.guides[1].coordinate
              
              1 person found this helpful
              • 4. Re: Get the local space of the guide lines
                SuperMerlin Level 5

                As an alternative to using guides you could use the ruler offset. Just drag the ruler offset to where you want.

                You can then get the results and reset the offset.

                Example:-

                alert(getRulerOffset());
                SetRulerOrigin(0,0);
                
                function getRulerOffset(){
                    var r = new ActionReference();
                    r.putEnumerated(stringIDToTypeID("document"), stringIDToTypeID("ordinal"), stringIDToTypeID("targetEnum")); 
                    var desc = executeActionGet(r);
                    var h= desc.getInteger(stringIDToTypeID("rulerOriginH"))>> 16;
                    var v= desc.getInteger(stringIDToTypeID("rulerOriginH"))>> 16;
                    return [h,v];
                };
                function SetRulerOrigin(horiz, vert) {
                    var desc = new ActionDescriptor();
                    var ref = new ActionReference();
                    ref.putProperty(app.stringIDToTypeID("property"), app.stringIDToTypeID("rulerOriginH"));
                    ref.putEnumerated(app.stringIDToTypeID("document"), app.stringIDToTypeID("ordinal"), app.stringIDToTypeID("targetEnum"));
                    desc.putReference(app.stringIDToTypeID("null"), ref);
                    desc.putInteger(app.stringIDToTypeID("to"), horiz << 16);
                    executeAction(app.stringIDToTypeID("set"), desc, DialogModes.NO);
                    var desc = new ActionDescriptor();
                    var ref = new ActionReference();
                    ref.putProperty(app.stringIDToTypeID("property"),app.stringIDToTypeID("rulerOriginV"));
                    ref.putEnumerated(app.stringIDToTypeID("document"), app.stringIDToTypeID("ordinal"), app.stringIDToTypeID("targetEnum"));    
                    desc.putReference(app.stringIDToTypeID("null"), ref);
                    desc.putInteger(app.stringIDToTypeID("to"), vert << 16);
                    executeAction(app.stringIDToTypeID("set"), desc, DialogModes.NO);
                };