एक नोड-आधारित ग्राफिकल इंटरफ़ेस को कार्यान्वित करना?

Question

मैं एक नोडल-इंटरफ़ेस को लागू करने, मूल रूप से चाहते हैं एक DAG जहां प्रत्येक नोड यह इनपुट कनेक्शन है पर कार्रवाई करता है, और आउटपुट कुछ (जो आप किसी अन्य नोड के लिए कनेक्ट कर सकते हैं)

कुछ उदाहरण अनुप्रयोगों:

• Apples "Shake" - screenshot
• The Foundrys "Nuke"-screenshot
• MindNode - screenshot
• vvvv-screenshots
• Quartz Composer - screenshot

---

एक पहला लक्ष्य के रूप में, मैं केवल 2 नोड्स के साथ एक चित्रमय आवेदन करना चाहते हैं। एक "संख्या" जो बस एक निश्चित संख्या को आउटपुट करता है, और एक "जोड़ें" नोड, जो दो इनपुट लेता है और दोनों के योग को आउटपुट करता है।

class Number: 
    def __init__(self, value): 
     self.value = value 

    def eval(self): 
     return self.value 

class Add: 
    def __init__(self, input1, input2): 
     self.input1 = input1 
     self.input2 = input2 

    def eval(self): 
     return self.input1.eval() + self.input2.eval() 


a = Number(20) 
b = Number(72) 

adder = Add(a, b) 
print adder.eval() 

मैं कैसे रैपिंग के बारे में मिल गया होगा:

के रूप में लोगों को इतनी-दूर का जवाब दे दिया है, मैं देख छद्म कोड, कोड में डेटा का प्रतिनिधित्व करने के लिए कैसे Python'y में उदाहरण के लिए का मोटा अनुमान है इस के आसपास एक कस्टम जीयूआई? निम्नलिखित की तरह कुछ, लेकिन थोड़ा कम हाथ से तैयार!

मैं कहां से शुरू होगा? मैं वर्तमान में इसे उद्देश्य-सी/कोको में लिखने की योजना बना रहा हूं, हालांकि मैं अन्य भाषाओं के लिए सुझावों के लिए खुला हूं।

Answer 1

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

कुछ सामान्य सी शैली OOP भाषा में (आशा है कि यह समझ में आता है):

class Node<T> { 
    Node<T>[] inputs; 
    T eval(); 
} 

class AdderNode extends Node<int> { 
    int eval() { 
     int accum = 0; 
     for (inputs : i) 
      accum += i.eval(); 
     return i; 
    } 
} 

class ConstNode<int I> extends Node<int> { 
    int eval() { return I; } 
} 

AdderNode a; 
a.inputs.add(ConstNode<2>()); 
a.inputs.add(ConstNode<3>()); 
a.eval(); 

आप कुछ अमूर्त वर्ग, सामान्य, या इंटरफेस के साथ पूर्णांक बदल कर भी इस पर विस्तार कर सकता है। वास्तविक कार्यान्वयन वास्तविक भाषा के आधार पर अलग-अलग होगा।

Answer 2

मैं दिलचस्प संचालन मॉडलिंग के साथ शुरू करूंगा। आखिरकार आप उन्हें यूआई से जोड़ देंगे, लेकिन वह स्टीयरिंग व्हील और गैस पेडल है, इंजन नहीं।

जो आप बनाने का प्रयास कर रहे हैं वह प्रोग्रामिंग भाषाओं के साथ बहुत आम है: चर, मूल्य, प्रकार, अभिव्यक्ति, मूल्यांकन इत्यादि। कई रूपक लागू होते हैं और कुछ मार्गदर्शन प्रदान कर सकते हैं।

यदि आप .NET 3.5 का उपयोग कर रहे हैं, तो आपके पास Expression Trees का विकल्प है, जो आपको रनटाइम पर कोड अभिव्यक्तियों का प्रतिनिधित्व और संकलन करने की अनुमति देता है।

using System.Linq.Expressions; 

ConstantExpression theNumber2 = Expression.Constant(2); 
ConstantExpression theNumber3 = Expression.Constant(3); 

BinaryExpression add2And3 = Expression.Add(theNumber2, theNumber3); 

अभिव्यक्ति आह्वान करने के लिए, हम एक विधि के साथ add2And3 रैप करने के लिए की जरूरत है:

उदाहरण के लिए, अपना पहला लक्ष्य मॉडल करने के लिए। यह एक लैम्ब्डा अभिव्यक्ति के साथ किया जाता है:

Expression<Func<int>> add2And3Lambda = Expression.Lambda<Func<int>>(add2And3); 

Func<int> एक तरीका है जिसके कोई पैरामीटर लेता है और एक int रिटर्न प्रतिनिधित्व करता है। सी # में, कोड add2And3Lambda द्वारा प्रतिनिधित्व होगा:

() => 2 + 3 

तो एक अभिव्यक्ति पेड़ जिसका जड़ एक तरीका है कि हम क्या है। क्योंकि एक विधि प्रतिदेय है, हम अंतर्निहित प्रतिनिधि प्रकार का एक उदाहरण में पेड़ संकलन कर सकते हैं:

Func<int> add2And3Func = add2And3Lambda.Compile(); 

अब हम कोड हम बनाया आह्वान कर सकते हैं: करने के लिए

int theNumber5 = add2And3Func(); 

हर अभिव्यक्ति उपलब्ध। नेट भाषा समर्थित है।

कल्पना करें कि आपके ग्राफ में प्रत्येक नोड में Expression इसके साथ जुड़ा हुआ है। इससे आपको अभिव्यक्ति के पेड़ की शक्ति का पता चल सकता है और वे इस कार्य के साथ आपकी मदद कैसे कर सकते हैं।

Answer 3

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

• ग्राफिक्स: धुंधला (छवि, कर्नेल, त्रिज्या) -> छवि

• गणित: जोड़ें (संख्या, संख्या) -> संख्या

• संबंधपरक: फ़िल्टर (तालिका, विधेय) -> तालिका

मूल रूप से इस तरह Func<object[], object> (सी # एक समारोह हस्ताक्षर करने के लिए नीचे आता है)।

आपको अपने नोड सिस्टम को लगातार बनाए रखने के सवाल का सामना करना पड़ेगा। क्या आप केवल एक अन्य नोड (पेड़) या एकाधिक नोड्स (ग्राफ़) द्वारा पैरामीटर के रूप में उपयोग करने योग्य नोड का परिणाम बनाना चाहते हैं? ,

Add(
    Multiply(
    Constant(5), 
    Constant(4) 
), 
    Multiply(
    Constant(5), 
    Constant(3) 
) 
) 

एक ग्राफ का उदाहरण एक सूची में सभी नोड्स की दुकान और केवल संदर्भ का उपयोग: एक पेड़ की

उदाहरण के लिए, सीधे पैरामीटर एक बच्चे नोड्स है

A := Constant(5) 
B := Constant(4) 
C := Constant(3) 

D := Func(Multiply, A, B) 
E := Func(Multiply, A, C) 

F := Func(Add, D, E) 

Answer 4

शायद bwise है ब्याज की कुछ?

this page के निचले हिस्से में एक गुणात्मक ब्लॉक बनाने के लिए bwise का उपयोग करने का एक उदाहरण दिखाता है जो दो संख्याओं को इनपुट के रूप में लेता है।

Answer 5

मैं कोको में इस तरह के एक अंतरफलक को लागू करने पर कुछ उपयोगी जानकारी मिल:

• Intro to Quartz और Intro to Quartz II - काफी क्या मैं के लिए देख रहा था, एक कार्यान्वयन - एक NSView
• Cocoadev पर FlowChartView में बुनियादी ड्राइंग का वर्णन करता है क्वार्ट्ज संगीतकार इंटरफ़ेस का। GRSFramework

  स्रोत कोड पाया जा सकता है here:

Answer 6

मैं की तरह आप इस परियोजना में वर्णन एक निष्पादन ग्राफ़ को लागू किया।

वर्तमान में मैं इस प्रणाली के बेहतर, साफ संस्करण को ExecutionGraph में रिलीज़ करने पर काम कर रहा हूं।
यह आपके लिए भी रुचि का हो सकता है।

तो फिर वहाँ भी जो लागू किया TensorFlow

Answer 7

एक समान प्रणाली मैं इस सूत्र पर ठोकर खाई, जबकि एक समान समाधान के लिए शोध किया है गूगल से TensorFlow पुस्तकालय है। हाल ही में मुझे github https://github.com/nodebox/nodebox पर एक अच्छी परियोजना मिली जो आपको लगता है कि आप वास्तव में क्या देख रहे हैं। कम से कम एक परियोजना से संपादक घटकों को निकालने और अपनाने के लिए।

सादर, StackOverflow को स्टीफ़न