कैसे एक अच्छे युवा आदमी की कहानी तीन सिर वाले सांप से लड़ती है, या एडोब इनडिजाइन डॉक्यूमेंट्स में एसवीजी ग्राफिक्स कैसे एम्बेड करें - भाग दो

Wiklequick द्वारा इस पोस्ट की निरंतरता ।

पांच चरण, या कार्य शैली में शराबी मास्टर को लागू करें
अब, चूंकि हमारे पास पहले से ही आदिम हैं, चलो रंगों, अल्फा चैनल और रेखा शैलियों को लागू करते हैं।

  निजी शून्य applyStroke (आकृति आकृति) {
   स्ट्रोक स्ट्रोक = getStroke ();
   ट्रांसफ़ॉर्म t = getTransform ();
   अगर (स्ट्रोक! = अशक्त) {
     अगर (स्ट्रोक इंस्टाफॉरेक्ष् बेसिकस्ट्रोक) {
       बेसिकस्ट्रोक कर्स्ट्रोक = (बेसिकस्ट्रोक) स्ट्रोक;
       फ्लोट [] ff = curStroke.getDashArray ();
       if (ff! = null) setdash (ff.length, ff, currStroke.getDashPhase ());
       फ्लोट चौड़ाई = (फ्लोट) (करमस्ट्रोक.गेटलाइनडिथ () * मैथ.मैक्स (t.getScaleX (), t.getScaleY ()));
       if (चौड़ाई <0.7f) चौड़ाई = 0.7f;
       setlinewidth (चौड़ाई);
     }
     और {
       सेटलाइनवेड्थ (1.0f);
       आकृति स्ट्रोककैप = स्ट्रोक.क्रिकेट स्ट्रोक्डशैप (आकार);
       fill (strokedShape);
     }
   }
   अन्यथा 
     सेटलाइनवेड्थ (1.0f);
 }

सामान्य रूप से कोड में कुछ भी जटिल नहीं होता है, बस एक BasicStroke पार्सिंग। यदि यह कुछ और है, तो यह एक आकृति के रूप में प्रतिनिधित्व करने योग्य है और इसे उसी तरह खींचा जा सकता है।
अगला, हमें बाद के आकार के लिए अल्फा स्तर मिलता है, और इसे InDesign में पास किया जाता है - कोड भी काफी सरल है।

  निजी शून्य लागू () {
   फ्लोट अल्फा = 1.0f;
   समग्र COMP = getComposite ();
   अगर (COMP! = null && comp Instof AlphaComposite) {
     AlphaComposite alcomp = (AlphaComposite) COMP;
     अल्फ़ा = alcomp.getAlpha ();
   }
   अस्तव्यस्तता (अल्फा, सच);
 } 

लेकिन कस्टम पेंट और कंपोजिट से स्थिति बहुत दुखद है। मुझे उन्हें खुद को खतरे में डालना होगा।

  निजी बूलियन लागू (आकार) {
   पेंट पेंट = getPaint ();
   अगर (पेंट इंस्टाफॉ कलर) {
     रंग cc = (रंग) पेंट;
     setrgbcolor (cc.getRed () / 255.0f, cc.getGreen () / 255.0f, cc.getBlue () / 255.0f);
     if (cc.getAlpha) ()! = 0 && cc.getAlpha ()! = 255) सेटपेसिटी (cc.getAlpha () / 255.0f, true);
     और लागू करें;
   }
   और अगर (पेंट! = null && आकार! = null) {
     applyAlpha ();
     drawGradientAsBackground (आकार, पेंट);
     झूठे लौटना;
   }

   समग्र COMP = getComposite ();
   अगर (COMP! = null && !! (COMP Instof AlphaComposite) && shape! = null) {
     drawCustomComposite (आकार, COMP);
     झूठे लौटना;
   }
   सच लौटना;
 } 

रंग के साथ स्थिति काफी स्पष्ट है (सिवाय इसके कि अल्फा चैनल को स्पष्ट रूप से रंग के लिए सेट किया जा सकता है), लेकिन बाकी सभी को स्पष्टीकरण की आवश्यकता है। ध्यान दें कि फ़ंक्शन सही / गलत है। सत्य का अर्थ है कि कोई चाल लागू नहीं की गई थी, और वर्तमान आकार को भरना () के माध्यम से खींचा जाना चाहिए। लेकिन झूठ का मतलब है कि आकार पहले से ही एक तस्वीर के रूप में rasterized है और आपको इसे चित्र के ऊपर खींचने की आवश्यकता नहीं है।
ढाल को इस तरह खींचना पड़ा:

  निजी शून्य ड्रॉगिएरिएंटएबैक्सग्राउंड (आकृति आकार, पेंट पेंट) {
   GraphicsConfiguration conf = getDeviceConfiguration ();
   पेंटकोटेक्स्ट pctx = paint.createContext (
     conf.getColorModel (), conf.getBounds (), shape.getBounds2D (),
     getTransform (), getRenderingHints ());

   आयत r = getTransform ()। CreateTransformedShape (आकृति) .getBounds ();
   रेखापुंज रेखापुंज = pctx.getRaster (आरएक्स, आरवाई, आर.ओवर्शन, आर.हाईट);
   ColorModel cmodel = pctx.getColorModel ();
   बफ़रइमेज bfi = नया बफ़रमैज़ (cmodel, raster.createCompatibleWritableRaster (),)
     cmodel.isAlphaPremultiplied (), null);
   bfi.setData (raster);
  
   int [] argbBuf = getBuf (bfi, r.width, r.height);
   अगर (argbBuf! = null) {
     applyClip (आकार);
     drawImage (argbBuf, rx, ry, r.width, r.height, new AffineTransform ());
     रिस्टोरक्लिप ();
   }
   pctx.dispose ();
 } 

इस फ़ंक्शन में, ढाल को ऑफस्क्रीन छवि पर खींचा जाता है, और आकार ही क्लिपिंग चित्र होता है। उसी तरह हम गैर-मानक कंपोजिट को प्रस्तुत करते हैं:

  निजी शून्य drawCustomComposite (आकार आकृति, समग्र COMP) {
   आयत r = getTransform ()। CreateTransformedShape (आकृति) .getBounds ();
   बफ़रेडइमेज bfi = नया बफ़रमैडम (r.width, r.height, BufferedImage.TYPE_INT_ARGB);
   Graphics2D g2 = (Graphics2D) bfi.getGraphics ();
   g2.setTransform (getTransform ());
   g2.setComposite (COMP);
   g2.fill (आकार);
   g2.dispose ();
  
   int [] argbBuf = getBuf (bfi, r.width, r.height);
   अगर (argbBuf! = null) {
     applyClip (आकार);
     drawImage (argbBuf, rx, ry, r.width, r.height, new AffineTransform ());
     रिस्टोरक्लिप ();
   }
 } 

चूंकि हम पहले से ही रूपांतरित आकृति बना रहे हैं, ड्राइमेज में हम एक खाली AffineTransform सेट करते हैं।

छठा चरण, या हम प्रतिकूल परिस्थितियों को प्राप्त करते हैं
अंत में, हम सबसे दिलचस्प हो गए। यदि अन्य मामलों के लिए मूल कार्यान्वयन अनिवार्य रूप से एकल-पंक्ति कोड है, तो चित्रों के मामले में ऐसा नहीं है। सबसे पहले, मैं चित्र देने के लिए एक कोड दूंगा:

  सार्वजनिक बूलियन ड्राइमेज (छवि img, int x, int y, int चौड़ाई, int ऊंचाई, रंग bgcolor, ImageObserver पर्यवेक्षक) {
   int [] argbBuf = getBuf (img, चौड़ाई, ऊंचाई);
   if (argbBuf == null) झूठे वापस;
    
   applyClip (getClip ());
   applyAlpha ();
   drawImage (argbBuf, x, y, width, height, getTransform ());
   रिस्टोरक्लिप ();
   सच लौटना;
 } 

कोड बहुत सरल है - क्लिपिंग, अल्फा चैनल सेट करता है, बिट मैट्रिक्स प्राप्त करता है - और इसे सभी InDesign को पास करता है। बिट्स प्राप्त करना स्पष्ट है:

  निजी int [] getBuf (छवि img, int चौड़ाई, int ऊंचाई) {
   int [] argbBuf = नया int [चौड़ाई * ऊंचाई];
   PixelGrabber pg = new PixelGrabber (img, 0, 0, चौड़ाई, ऊंचाई, argbBuf, 0, चौड़ाई);
   कोशिश करो {
     if (pg.grabPixels ()) null वापसी;
   }
   पकड़ (व्यवधानबोधक e) {वापसी अशक्त;  }
   अगर ((pg.getStatus () & ImageObserver.ABORT)! = 0) अशक्त लौटें;
   वापसी argbBuf;
 } 

लेकिन InDesign में स्थानांतरण की कुछ विशेषताएं हैं। उन पर विचार करें।

  निजी शून्य ड्राइमेज (int [] argbBuf, int x, int y, int चौड़ाई, int ऊंचाई, AffineTransform परिवर्तन) {
   डबल [] ट्रांसमैटर = नया डबल [6];
   transform.getMatrix (transMatr);
   this.image (argbBuf, x, y, width, height, transMatr);
 } 

यह देखना आसान है कि यह एकमात्र फ़ंक्शन है जो परिवर्तन मैट्रिक्स को InDesign में स्थानांतरित करता है, और अपने आप ही काम नहीं करता है। एक दूसरे रास्ते पर जा सकता है, और परिवर्तन मैट्रिक्स को हमेशा डिज़ाइन में स्थानांतरित किया जाना चाहिए, और रूपांतरित आकृति के साथ काम नहीं करना चाहिए। लेकिन, मेरे बड़े अफसोस के साथ, डिजाइन के साधनों के साथ ग्रेडिएंट खींचने में असमर्थता ने इस तरह के निर्णय का नेतृत्व किया।
और अब C ++ में वापस जाएं और प्लगइन की बारीकियों पर विचार करें। यहां बहुत सारे कोड हैं, इसलिए मैं केवल सबसे दिलचस्प अंश दूंगा, तुच्छता और त्रुटि से निपटने को हटा दूंगा।
शुरुआत स्पष्ट है:

  JNIEXPORT शून्य JNICALL Java _..._ छवि
   (जेएनएनवीवी * एनवी, जॉबजेक्ट ओब्ज, 
   jintArray imageARGBBuff, jint x, jint y, jint चौड़ाई, jint ऊंचाई,
   jdoubleArray ट्रांसफॉर्मर मैट्रिक्स) {

   K2 :: scoped_array <uint8> maskBuffer (नया uint8 [imageARGBBuff.length]);
   K2 :: scoped_array <uint8> pictBuffer (नया uint8 [3 * imageARGBBuff.length]);

// हमारे ARGB में बफ़र्स भरें

लेकिन फिर एक नर्तकी के साथ नृत्य शुरू होता है।
यहाँ बात है: अगर हमारे पास ब्लेंडिंग स्पेस = RGB है, तो Design CMYK में एक चित्र चाहता है। अन्यथा, यह समय के माध्यम से गिरता है, नायक पर एक भयानक आध्यात्मिक घाव को भड़काता है, और इतना है कि नायक भी नहीं खा सकता है। और इसके विपरीत - यदि सम्मिश्रण रंग स्थान = CMYK है, तो चित्र RGB में होना चाहिए। यह प्रयोगात्मक रूप से पाया गया था, और यह सब इस तरह क्यों होता है - मुझे समझाना मुश्किल है। इसलिए, हमें यह पता लगाना होगा कि अब हमने कौन सा रंग स्थान निर्धारित किया है:

  यूटिल्स <IXPUtils> xpUtils;
 InterfacePtr <IXPManager> xpManager (xpUtils-> QueryXPManager (db));
 InterfacePtr <IDocument> doc (db, db-> GetRootUID (), UseDefaultIID ());
 AGMColorSpace * ब्लेंडिंगस्पेस = xpManager-> GetDocumentBlendingSpace ();

और यदि आवश्यक हो तो रूपांतरित करें:

  uint8 * outBuff = nil;
 int16 compCnt = 3, space = kRGBColorSpace;

 अगर (IsBeingFlattened (env, obj)) {
   TransformRGB2CMYKifNeeded (doc, blendingSpace, pictBuffer.get (), & outBuff, imageARGBBuff.length);
   compCnt = 4;  space = kCMYKColorSpace;
   pictBuffer.reset (outBuff);
 } 

अब हम एक चित्र और एक अल्फा मास्क दोनों तैयार करने के लिए तैयार हैं:

  AGMImageRecord imgR;
 मेमसेट (& imgR, 0, sizeof (AGMImageRecord));

 imgR.bounds.xMin = x;
 imgR.bounds.yMin = y;
 imgR.bounds.xMax = x + चौड़ाई;
 imgR.bounds.yMax = y + height;
 imgR.byteWidth = compCnt * चौड़ाई;
 imgR.colorSpace = space;
 imgR.bitsPerPixel = compCnt * 8;
 imgR.baseAddr = (void *) pictBuffer.get ();

 AGMImageRecord maskR;
 मेमसेट (& maskR, 0, sizeof (AGMImageRecord));
 maskR.bounds.xMin = x;
 maskR.bounds.yMin = y;
 maskR.bounds.xMax = x + चौड़ाई;
 maskR.bounds.yMax = y + height;
 maskR.byteWidth = चौड़ाई;
 maskR.colorSpace = kGrayColorSpace;
 maskR.bitsPerPixel = 8;
 maskR.baseAddr = (void *) maskBuffer.get ();

यह केवल जावा प्रारूप से InDesign प्रारूप में परिवर्तन मैट्रिक्स से आगे निकलने के लिए बना हुआ है:

  पीएममैट्रिक्स ट्रांसफॉर्म (nativeTransformData [0], nativeTransformData [1])
 nativeTransformData [2],
    	 nativeTransformData [3], 
 nativeTransformData [4], 
 nativeTransformData [5]); 

अंतिम स्पर्श - आपको अल्फा चैनल मास्क के बारे में वर्णमाला के ज्ञान से अवगत कराने की आवश्यकता है:

  AGMPaint * AlphaServer = xpUt-> CreateImagePaintServer (& maskR, & transform, 0, nil);
 PMRect सीमा (x, y, चौड़ाई + x, ऊंचाई + y); 

  port-> सेटअल्फासेवर (अल्फासेवर, केट्र्यू, स्टब); 

  port-> starttransparencygroup (सीमा, सम्मिश्रण, kFalse, kFalse); 

और आप आखिर में एक तस्वीर खींच सकते हैं। हमने कर दिखाया!

  port-> छवि (& imgR, बदलना, drawFlags); 

मैं अल्फा सर्वर और अन्य चीजों की सफाई के लिए कोड प्रदान नहीं करता हूं, क्योंकि यह तुच्छ है।

पिछले भाग, या हम पराजित राक्षस के खजाने को बाहर निकालते हैं
तो इस तरह, तीन-सिर वाले सांप को हराने के लिए अच्छे साथी के लिए यह संभव था, और लेखक - एडोब इनडिज़ाइन एसडीके में प्लग-इन के सबसे खराब दस्तावेज प्रकारों में से एक के साथ पहले से ही हेजहोग को पार करने के लिए। दुर्भाग्य से, सुधार के लिए स्थान थे, उदाहरण के लिए, समान ग्रेडिएंट, लेकिन अंतिम परिणाम काफी संतोषजनक था।
यह कहानी का अंत है, और जिसने भी सुना वह अच्छी तरह से किया गया है!