क्या अतिव्यापी बिंदुओं के लिए लेबल को एक लेबल में संयोजित / मर्ज किया जा सकता है?

Question

मेरे पास नमूना स्थानों का प्रतिनिधित्व करने वाले बिंदु हैं। अक्सर, एक ही स्थान पर कई नमूने लिए जाएंगे: एक ही स्थान पर विभिन्न नमूने आईडी और अन्य विशेषताओं के साथ कई बिंदु। मैं उन सभी बिंदुओं को लेबल करना चाहता हूं, जो एक ही लेबल के साथ सह-स्थित हैं, उस स्थान के सभी बिंदुओं के सभी नमूना आईडी को ढेर किए गए पाठ सूची के साथ।

क्या आर्कगिस में या तो नियमित लेबलिंग इंजन या मैपलेक्स का उपयोग करना संभव है? मुझे पता है कि मैं एक विशेषता मूल्य में प्रत्येक स्थान के लिए सभी नमूना आईडी के साथ एक नई परत बनाकर इसके चारों ओर काम कर सकता हूं, लेकिन मैं केवल लेबलिंग के लिए नया डेटा बनाने से बचना चाहूंगा।

मूल रूप से मैं इससे जाना चाहता हूं:

इसके लिए (सबसे ऊपरी बिंदु के लिए):

लेबल के किसी भी मैनुअल संपादन के बिना।

Comments

आपके डेटासेट में कितने बिंदु हैं?

— हॉर्नबड जूल 28'15

Answer 1

ऐसा करने का एक तरीका परत को क्लोन करना है, परिभाषा प्रश्नों का उपयोग करना और उन्हें अलग से लेबल करना, पहली परत के लिए ऊपरी-बाएँ केवल लेबल स्थिति का उपयोग करना और दूसरे के लिए निचला-बाएँ।

लेयर की अभिव्यक्ति का उपयोग करके लेयर में टाइप करें और इसे पॉप्युलेट करें:

aList=[]
def FirstOrOthers(shp):
 global aList
 key='%s%s' %(round(shp.firstPoint.X,3),round(shp.firstPoint.Y,3))
 if key in aList:
  return 2   
 aList.append(key)
 return 1

इसे कॉल करें:

FirstOrOthers( !Shape! )

सामग्री की तालिका में परत की एक प्रति बनाएं, परिभाषा क्वेरी THEFIELD = 1 लागू करें।

मूल परत के लिए परिभाषा क्वेरी THEFIELD = 2 लागू करें।

अलग-अलग निश्चित लेबल प्लेसमेंट लागू करें

मूल समाधान के लिए टिप्पणियों पर आधारित अद्यतन:

फ़ील्ड COORD जोड़ें और इसका उपयोग करके पॉप्युलेट करें

'%s %s' %(round( !Shape!.firstPoint.X,2),round( !Shape!.firstPoint.Y,2))

लेबल के लिए पहले और अंतिम का उपयोग करके इस क्षेत्र को सारांशित करें। COORD फ़ील्ड का उपयोग करके इस तालिका को मूल में शामिल करें। उन रिकॉर्ड्स का चयन करें जहां <> अंतिम और एक नए क्षेत्र में पहले और अंतिम लेबल का उपयोग कर रहा है

'%s\n%s' %(!Sum_Output_4.First_MUID!, !Sum_Output_4.Last_MUID!)

2 'विभिन्न परतों' और उन्हें लेबल करने के लिए खेतों को परिभाषित करने के लिए Count_COORD और THEFIELD का उपयोग करें:

#Hornbydd समाधान से प्रेरित # 2 अपडेट करें:

import arcpy
def FindLabel ([FID],[MUID]):
  f,m=int([FID]),[MUID]
  mxd = arcpy.mapping.MapDocument("CURRENT")
  dFids={}
  dLabels={}
  lyr = arcpy.mapping.ListLayers(mxd,"centres")[0]
  with arcpy.da.SearchCursor(lyr,["FID","SHAPE@","MUID"]) as cursor:
    for row in cursor:
       FD,shp,LABEL=row
       XY='%s %s' %(round(shp.firstPoint.X,2),round( shp.firstPoint.Y,2))
       if f == FD:
         aKey=XY
       try:
          L=dFids[XY]
          L+=[FD]
          dFids[XY]=L
          L=dLabels[XY]
          L=L+'\n'+LABEL
          dLabels[XY]=L
       except:
          dFids[XY]=[FD]
          dLabels[XY]=LABEL
  Labels=dLabels[aKey]
  Fids=dFids[aKey]
  if f == Fids[0]:
    return Labels
  return ""

UPDATE नवंबर 2016, उम्मीद से आखिरी।

2000 डुप्लिकेट पर जांच की गई अभिव्यक्ति के नीचे, आकर्षण की तरह काम करता है:

mxd = arcpy.mapping.MapDocument("CURRENT")
lyr = arcpy.mapping.ListLayers(mxd,"centres")[0]
dFids={}
dLabels={}
fidKeys={}
with arcpy.da.SearchCursor(lyr,["FID","SHAPE@","MUID"]) as cursor:
 for FD,shp,LABEL in cursor:
  XY='%s %s' %(round(shp.firstPoint.X,2),round( shp.firstPoint.Y,2))
  fidKeys[FD]=XY
  if XY in dLabels:
   dLabels[XY]+=('\n'+LABEL)
   dFids[XY]+=[FD]
  else:
   dLabels[XY]=LABEL
   dFids[XY]=[FD]

def FindLabel ([FID]):
  f=int([FID])
  aKey=fidKeys[f]
  Fids=dFids[aKey]
  if f == Fids[0]:
    return dLabels[aKey]
  return "

Comments

अरे आपने इसे फटा दिया! अच्छा! मुझे पता था कि वहाँ कोई है जो बाहर चक्कर आ रहा था! जैसा कि मुझे उम्मीद थी कि यह एक बहुत ही पुनरावृत्ति प्रक्रिया है, इसलिए एक बड़े डेटासेट पर चलते हैं और लेबल हमेशा के लिए खींचते हैं (अच्छी तरह से यह मेरे डेटा डेटा पर)। मैंने कुछ पंक्तियों का विस्तार करके आपकी कोड शैली को बदल दिया है। मुझे लगता है कि न्यूनतावादी, एक पंक्ति में सभी का पालन करना मुश्किल है।

— हॉर्नबड

@Hornbydd संपादन के लिए धन्यवाद। लेबल (इंजन?) व्यवहार के कारण इस नट को क्रैक करना मुश्किल था। यह फ़ंक्शन के सभी मापदंडों को स्ट्रिंग्स के रूप में मानता है! यही कारण है कि पहले IF बिना f = int ([FID]) के बिना काम नहीं करता था। गति के बारे में मैं इसे 50 से अधिक बिंदुओं पर सेट पर कभी उपयोग नहीं करूंगा। इसे स्क्रिप्ट में परिवर्तित करना होगा जो केवल दो बार डेटासेट के माध्यम से नए क्षेत्र को पॉपुलेट करता है: 1) दोनों शब्दकोशों को संकलित करने के लिए खोज कर्सर, 2) उनसे पढ़ने के लिए कर्सर को अद्यतन करें नोट: पहले 3 पंक्तियाँ कोशिश बयान के बाद अप्रचलित हैं, समाधान पोस्ट करने के बाद। एहसास हुआ कि उन्हें सुरक्षित रूप से हटाया जा सकता है।

— फेलिक्सिप

FYI करें मुझे इस पर वापस जाने का मौका नहीं मिला, लेकिन मैं आपके समाधान को अगले सप्ताह या इसके बाद एक चक्कर देने की योजना बना रहा हूं। पायथन के साथ एक और वर्कअराउंड (एक मैंने इस मामले में इस्तेमाल किया है), मैं उस के बारे में भी जवाब दूंगा।

— डेन सी

जियोनेट पर इस पृष्ठ पर आया । मुझे वैश्विक शब्दकोशों का चतुर प्रयोग पसंद आया और फिर इस प्रश्नोत्तर के बारे में सोचा और इसमें एक कड़ी जोड़ी।

— हॉर्नबीड

@ हॉर्नबीड हां, यह रिचर्ड की हर चीज की तरह बहुत स्मार्ट और विस्तृत है और इससे मेरे (हमारे) समाधान पर बहुत फर्क पड़ेगा। कुछ लाइनों को हटाकर एक को और बेहतर बनाया जा सकता है जिसमें पहले वाला ही शामिल है। हालांकि ओपी के प्रतिक्रिया समय के आधार पर ऐसा लगता है कि उसने रुचि खो दी है, मैं या तो परेशान नहीं हूं

— फेलिक्सिप

Answer 2

नीचे एक आंशिक समाधान है।

यह एडवांस लेबल अभिव्यक्ति में जाता है। यह बहुत कुशल नहीं है इसलिए मुझे आपके डेटासेट में अंकों की संख्या के बारे में पूछना है। इसलिए प्रत्येक पंक्ति के लिए जिसे लेबल किया जाता है वह 2 शब्दकोशों का निर्माण करता है dजहां कुंजी XY है और मान पाठ है और d2जो ऑब्जेक्ट और XY है। शब्दकोशों के उस संयोजन का उपयोग करके यह एक एकल लेबल को वापस करने में सक्षम है जो कि नईलाइन वर्णों के साथ एक संयोजन है, मेरे उदाहरण में यह TARGET_FID को समाप्‍त कर रहा है। TOC में "sj" परत नाम है।

import arcpy
def FindLabel ( [OBJECTID] ):
  ob = str([OBJECTID])
  mxd = arcpy.mapping.MapDocument("CURRENT")
  d ={}
  d2 = {}
  lyr = arcpy.mapping.ListLayers(mxd,"sj")[0]
  with arcpy.da.SearchCursor(lyr,["OID@","SHAPE@XY","TARGET_FID"]) as cursor:
    for row in cursor:
      objID = str(row[0])
      temp = row[1]
      tup = str(temp[0]) + "," + str(temp[1])
      d2[objID] = tup
      txt = str(row[2])
      if tup in d:
        v = d[tup] 
        v = v + "\n" + txt
        d[tup] = v
      else:
        d[tup] = txt  
  temp = d2[ob]
  return d[temp]

यह एक आंशिक समाधान क्यों है कि यह हर बिंदु के लिए किया जाता है, मैं यह सोचने में सक्षम नहीं हूं कि आप अन्य सभी स्टैक्ड बिंदुओं को कैसे बंद करेंगे। ऐसा इसलिए है क्योंकि मुझे लगता है कि अंतिम समाधान कुछ अजगर है जो अंकों के ढेर से निर्मित एकल लेबल के साथ एकल बिंदुओं की एक नई परत बनाता है।

नीचे 3 स्टैक्ड पॉइंट्स का आउटपुट है जैसा कि आप देख सकते हैं कि लेबल प्रत्येक बिंदु के लिए बनाया गया है क्योंकि वे सभी एक ही स्थान पर मौजूद हैं।