>> TOMAS Reimers: Cool.
ასე hi, ყველას.
ჩემი სახელის Tomas.
მე TF და ამ
Armaghan BEHLUM: Armi.
ლამაზი, რომ ნახოთ თქვენ ბიჭები.
TOMAS Reimers: Cool.
ამიტომ ჩვენ ვაპირებთ იყოს საუბარი შესახებ Leap Motion დღეს.
ასე Leap Motion არის მართლაც მაგარი პროდუქტი, რომელიც
გაძლევთ ურთიერთქმედება კომპიუტერული სხვაგვარად.
ასე რომ მთელი იდეა უკან ნახტომი მოძრაობაში არის, რომ თქვენ
შეგიძლიათ გამოიყენოთ თქვენს ხელშია ურთიერთქმედება კომპიუტერი.
ამიტომ სწორედ აქ მე მაქვს რაღაც შეიქმნა.
მე ამაზე ცოტა.
მაგრამ ძირითადი ვერსია შეგიძლიათ ვხედავ, რომ მე მაქვს ჩემი ხელები წინ
ჩემი კომპიუტერი და როცა გადაადგილება მათ, თქვენ გაქვთ ანალოგური on კომპიუტერი
და თქვენ შეგიძლიათ ანალიზი ამ.
თქვენ შეუძლია ჟესტები.
თქვენ შეგიძლიათ გამოიყენოთ თქვენს ხელშია ურთიერთქმედება კომპიუტერული
ახალი და საინტერესო გზა.
>> ისე, მე რეალურად პირველი გსურთ გაივლის off to Armi
გაჩვენოთ რამდენიმე cool demos რა ზოგიერთი ადამიანი არ კეთდება ეს.
და მაშინ ჩვენ ვსაუბრობთ, თუ როგორ თქვენ რეალურად კოდი ამ.
Armaghan BEHLUM: ჰო.
Hello.
ასე რომ, როგორც ჩვენ ვნახეთ, ცოტა მონაცემები აქ, მაგრამ ვნახოთ
რასაც ზოგიერთი ადამიანი არ კეთდება ეს.
ნება მომეცით, უბრალოდ გახსენით ეს მაგალითი.
და შემდეგ, ასე, მაგალითად, თქვენ შეგიძლიათ ნახოთ ჩემი მხრივ ანალოგი არსებობს, მაგრამ ახლა ამ დროს
ზოგიერთი ადამიანი გამოყენებით ერთობა აქვს გადავწყვიტეთ, რომ ცოტა მეტი კანის
და პერსონალის გარშემო მხრივ.
ასე, რომ შეიძლება, მოდით წავიდეთ ამ ერთი, რა თქმა უნდა, აქვს ჩემს ხელში ძალებთან.
და თქვენ ალბათ წარმოსადგენია რამდენიმე სხვა მაგარი რამ სასარგებლო
რომ შეგიძლიათ გააკეთოთ ეს.
ასე რომ ეს არის ერთი მაგალითი მაინც.
და მაშინ მოდით გადმოხტა ეს.
>> შემდეგ კი კიდევ ერთი მაგარი ერთი არის, მოდით წავიდეთ ერთად ამ ერთი.
Plasmo დაადასტურა.
კიდევ ერთხელ, ჩვენ გვინდა არ არის აუცილებელი ველით, რომ ამ დონის სირთულის
საწყისი საბოლოო პროექტი CS50.
ეს უბრალოდ გაჩვენებთ ზოგიერთი, მოგაწვდით ბიჭები
ცოტა შთაგონების რა შენ შეიძლება გააკეთოს ნახტომი Motion.
ასე მაგალითად, აქ არის მაგარი ფიზიკის მაგალითად, რომელიც იქ ჩვენ წავიდეთ.
აქვს ორივე, ჩემი ხელები, ასე რომ, ახლა ამ პატარა პლაზმური ბურთი.
და ბურთი რეაგირებს ფიზიკა ჩემთვის მოძრავი ჩემი მხრივ გარშემო ბურთი.
ეს არის ყველა იმისა, რომ გამოყენებით ერთობა, გამოყენებით სახის იარაღები და ფარგლებში
რომ ჩვენ არ ისწავლება თქვენ ბიჭები კლასში,
მაგრამ, როგორც ხედავთ, საკმაოდ მაგარი პერსპექტივაში throughs რომ.
>> მაგრამ ერთი რამ, რომ თქვენ ბიჭები შეუძლია გააკეთოს დაწყებული off ახლა Leap Motion
მუშაობა JavaScript.
Leap Motion აქვს JavaScript API რომელიც თქვენ ბიჭები შეგიძლიათ გამოიყენოთ და ჩვენ ძალიან, ძალიან
გირჩევთ, რომ თქვენ ბიჭები აშენება თქვენი პროექტების გამოყენებით, რომ.
ასე რომ, ნება მომეცით გაიაროს ეს back off to Tomas
ვისაუბროთ Leap შუამდგომლობა და JavaScript.
TOMAS Reimers: Cool.
ან არ გსურთ ნახოთ მათ Visualizer პირველი?
>> Armaghan BEHLUM: ჰო.
დიახ.
მოდით ვისაუბროთ უფრო მეტი, რომ Visualizer.
>> TOMAS Reimers: ასე რომ ძირითადი დონეზე, როდესაც თქვენ პირველ მისაღებად Leap Motion
თქვენ ვაპირებთ აქვს ამ ყუთში.
აქ, მინდა ჩემთვის აღებას?
>> Armaghan BEHLUM: Yeah, წავიდეთ ეს.
>> TOMAS Reimers: ასე რომ, როდესაც თქვენ პირველ მისაღებად Leap Motion
თქვენ ვაპირებთ აქვს ამ ყუთში.
მას აქვს მოწყობილობა, რომელიც ასე გამოიყურება.
თქვენ შეაერთედ ის თქვენს კომპიუტერში, ინსტალაცია საჭირო მძღოლები,
და მაშინ ეს იქნება ძირითადად შეიქმნება.
ასე იოლი გზა დასალაგებლად გარიგების Leap Motion
არის გახსენით ეს პროგრამა მოყვება მოუწოდა Leap Motion Visualizer.
და Visualizer სიტყვასიტყვით რა მე აჩვენებს აქ.
ეს გაძლევთ საშუალებას ნახოთ ჩონჩხის მონახაზი თქვენს ხელშია.
და რა Leap Motion არის წერით მათ.
ასე Leap Motion იყენებს კამერა სახის შევხედოთ თქვენს ხელშია
და მაშინ იგი ცდილობს გამოიცნოს რა ძირითადი ჩონჩხის შემადგენლობა, რომ თქვენ
ეკრანზე არის.
და რომ ის, რაც გიჩვენებთ.
Armaghan BEHLUM: ყველა ერთი პატარა წერტილი
და ის, რომ თქვენ ხედავთ, არსებობს მონაცემები, რომ ის ხელმისაწვდომი თქვენ ბიჭები
ასევე გამოიყენოს.
ასე რომ თქვენ ხედავთ, რომ ეს აღების, რომ Tomas
აქვს ხუთი თითი, თითოეული იმ სხვადასხვა თითების
ასევე შესაძლებელია თქვენთვის, როგორც მონაცემები რაოდენობა უნდა გამოიყენოს ნებისმიერი განცხადება
რომ დაგვჭირდება.
თუ გსურთ, რომ, თუ ვინმეს აკეთებს thumbs up
თქვენ ხედავთ, თუ მათი თითები მათ curled და თუ არა ისინი
ცერა თითის მიუთითებს ზემოთ, ან სადაც
მათი მაჯის ან პალმის და რომ ამ სახის პერსონალი.
TOMAS Reimers: Cool.
ასე რომ თქვენ ხედავთ რამდენიმე ჟესტები ეს უკეთ, ვიდრე სხვები.
გახსოვდეთ, რომ იგი ეძებს თქვენს ხელით at კამერა ბოლოში,
ასე რომ, როდესაც თქვენ თქვენი ხელები, როგორიცაა ეს ის ესმის, მათ სრულად,
მაგრამ ერთხელ თქვენ დაიწყოს ცდილობენ და ამის გაკეთება thumbs up, ზოგჯერ ნათქვამია,
ზოგჯერ ეს შეიძლება ვხვდები, მაგრამ პატიოსნად კამერა უბრალოდ ვერ ვხედავ thumb.
ასე რომ, ეს ნამდვილად არ არის დარწმუნებული ვარ, რა ხდება.
მხოლოდ გარკვეული შეზღუდვები უნდა გვახსოვდეს როდესაც თქვენ განვითარებადი ამ.
>> ყოველ შემთხვევაში, ასე ბრუნდება ამ.
Visualizer რეალურად აქვს ბევრი სასარგებლო ინსტრუმენტები.
ასე Leap Motion არის დაპროგრამებულია ისე,
რომ ისინი არ ველით, რომ თქვენ ურთიერთქმედება რომ image მონაცემები.
ისინი ნამდვილად არ ველით თქვენ უნდა გვესმოდეს,
რა ხდება კულისებში.
რასაც ისინი აკეთებენ, გამოამჟღავნონ რამოდენიმე APIs თქვენთვის
ისეთი, რომ თქვენ შეგიძლიათ ურთიერთქმედება ამ მონაცემთა
პირდაპირ გარეშე გაგება რა ხდება ქვეშ hood.
>> ასე რომ, თუ ჩვენ მოხვდა H აქ Visualizer დაინახავთ ბევრი ვარიანტი.
მნიშვნელოვანია აქ, თუმცა არის თუ მოხვდა O და შემდეგ მოხვდა H,
თქვენ დაინახავთ, რომ ეს გაძლევთ მიაპყროს ჟესტები.
ასე ჟესტი, დაინახავთ იგი ამახვილებს arrow მასშტაბით.
ჟესტი არის ერთ-ერთი გზა, რომელიც Leap Motion სახის გაძლევთ მიიღოთ მონაცემები
გარეშე პროცესის.
ასე რომ, ვიდრე me სჭირდება გაერკვნენ გარეთ, oh, ხელი მოძრაობდა,
მაშინაც კი, თუ მე მაქვს წერტილი ხელმისაწვდომობის, API იქნება ერთგვარი უბრალოდ მეუბნებოდა,
hey, მათ ეს ჟესტი.
ასე რომ თქვენ შეუძლია ძირითადი arrow ჟესტები.
თქვენ შეგიძლიათ მიიღოს წრე ჟესტები.
თქვენ შეუძლია მოსმენების ჟესტები.
და შეგიძლიათ კლავიშების ჟესტები.
Yeah.
და რომ მსგავსი საქმიანობები.
ასე რომ, ახლა, რომ ჩვენ გვაქვს ერთგვარი ჩანს, თუ რა Leap Motion შეუძლია გააკეთოს,
თქვენ ხედავთ, რომ წაიკითხოს მთელი bunch of ჟესტები.
მე ვფიქრობ, რომ მე ვაპირებ გაივლის მას უკან Armi
და ის აპირებს გაიგო, თუ როგორ თქვენ მიიღებთ ამ JavaScript,
როგორ კი დაიწყება პროექტის ამ.
და მაშინ ჩვენ ვსაუბრობთ, რაღაც cool ადგილებში შეგიძლიათ რომ.
Armaghan BEHLUM: ჰო.
ხმები კარგი.
ისე ჰო, პირველი, რაც ჩვენ იქნება მინდა, რა თქმა უნდა,
მას შემდეგ, რაც თქვენ მიიღებთ Leap Motion არის წასვლა leapmotion.com შეიქმნა, ინსტალაცია
მძღოლები და პერსონალი.
შემდეგ აკეთებს, რომ შეგიძლიათ წასვლა დარწმუნდით, რომ ის დაკავშირებული.
თუ ხედავთ თქვენი პატარა უჯრა Leap Motion ხატი და ეს მწვანე,
მაშინ თქვენ იცით, თქვენ ყველა მითითებული.
და რა თქმა უნდა შეამოწმოს, თუ რა Tomas უბრალოდ აჩვენა თქვენ ჟესტების
და აკეთებს ეკრანზე ონკანები, ვენტილები და გასაღები ონკანები, და რომ ამ სახის პერსონალი.
>> შემდეგ, რომ მიუხედავად იმისა, რომ ჩვენ, კიდევ ერთხელ, როგორც ვთქვი,
ჩვენ გვაქვს წვდომა ყველა ამ რამ JavaScript ისევე.
იდეალური შეიქმნა, რომ ჩვენ გირჩევთ
ბიჭები წასვლას თქვენი vhost დირექტორია, ადგილობრივი მასპინძელი,
საჯარო თქვენს CS50 ელექტრო მოწყობილობების.
და როდესაც თქვენ იქ რა თქვენ ვხედავ არის ინდექსი dot HTML ფაილი.
ახლა ეს მაჩვენებელი dot HTML ფაილი ან ინდექსი dot
PHP ფაილი, რომელი ჯარიმა, თუ რა შეგიძლიათ მაშინ ნუ
წასვლა თქვენი ძირითადი ოპერაციული სისტემა.
და თუ წასვლა IP მისამართი რომ ჩამოთვლილი ქვედა მარჯვენა
კუთხეში თქვენი მოწყობილობის სწორედ აქ, როგორც ხედავთ, მაშინ რა ხდება,
არის წასვლა გვერდზე რომ არის დამოწმებული, რომ ინდექსი dot HTML ფაილი.
ასე რომ ყველა კოდი, რომ თქვენ შეიძლება დააყენა არსებობს იღებს გაგზავნილი და გამოსადეგი აქ.
>> TOMAS Reimers: ასე რომ, ეს ასევე მნიშვნელოვანი მხოლოდ მინიშნება
რომ, თუ თქვენ ბიჭები ნამდვილად ვიცი, როგორ უნდა შეიქმნას სერვერზე თავს,
ან გსურთ დააყენა ამ მსოფლიოში ვებ, თქვენ მივესალმებით გავაკეთოთ რასაც.
გახსოვდეთ, რომ ეს არის უბრალოდ JavaScript ფაილები
და ყველა Leap დამუშავება კეთდება კლიენტს.
ასე რომ, ეს ნამდვილად არ აქვს სადაც თქვენს სერვერზე ცხოვრება
ასე რომ, სანამ კომპიუტერი თქვენ ათვალიერებენ ვებ-გვერდზე
აქვს Leap Motion დაყენებული.
Armaghan BEHLUM: რა თქმა უნდა.
როგორიცაა Tomas განაცხადა, yeah, რაც არ მუშაობს, თქვენ ბიჭები.
ეს არის მხოლოდ ერთი ჩვენი რეკომენდაციები.
ახლა უნდა დაიწყოს გამოყენებით Leap Motion რას გააკეთებდა
არის, რომ თქვენ იმპორტი JavaScript ფაილი Leap Motion.
და მერე იქიდან რა შეგიძლიათ გააკეთოთ, ახლა
მე უბრალოდ ამ მუხლის მე tag შეიქმნა ID ტექსტი.
რამ, რომ ჩვენ გირჩევთ ვქმნით კონტროლერი პარამეტრები
for Leap Motion ერთად საშუალებას ჟესტები უნდა იყოს ნამდვილი.
ასე რომ იყოს იმ ჟესტები, რომ ვაჩვენეთ თქვენ
ბიჭები, წრე, და გასაღები სტეპის და ჩერდება,
ის არ ნაჩვენები თქვენ ბიჭები იყოს.
მაგრამ ჩვენ მაღალ რეკომენდაციას გამოყენებით იმ ასე რომ თქვენ არ იბრუნებს საჭე.
მათ, ვინც მართალია, გავლით იმ კონტროლერი პარამეტრები ნახტომი dot loop
და თქვენ ყველა მითითებული წასვლა.
რადგან მაშინ უბრალოდ უნდა განსაზღვრული ანონიმური ფუნქცია
რომ მიიღებს ჩარჩო ნახტომის Motion
და რომ ჩარჩო აქვს ყველა ინფორმაცია, რომ თქვენ აპირებთ უნდა.
>> TOMAS Reimers: ასე რომ მხოლოდ recap, თქვენ გაქვთ ერთი ობიექტი.
თქვენ გაქვთ ამ ფუნქციის უწოდებენ ნახტომი dot loop.
და თქვენ ეძახით ორი არგუმენტები.
თქვენ ეძახით ერთი, კონტროლერი პარამეტრები.
და არსებობს უამრავი პარამეტრები შეგიძლიათ დააყენა იქ.
ერთი ჩვენ ვაპირებთ აღვნიშნო არის საშუალებას ჟესტები.
და თუ იგი ტოლია ასეა, მაშინ შეგიძლიათ მიიღოთ დაშვება ამ ჟესტები
რომ ვაჩვენეთ თქვენ Visualizer.
>> და მაშინ მეორე არგუმენტი არის ფუნქცია, ეს სახის, როგორიცაა ზარის უკან
რომელიც დაერქმევა ყველა დრო ყოველ ფარგლებში Leap,
ასე რომ ყოველ ჯერზე ნახტომი რეესტრი, რომელიც თქვენი მხრივ ნაბიჯი, მას აქვს ახალი ჩარჩო.
და მოუწოდებს ამ ფუნქციის ერთი არგუმენტი, რომელიც არის ჩარჩო ობიექტი.
და რომ ფარგლებში ობიექტი აღწერს ფარგლებში, როგორც Leap ხედავს.
Armaghan BEHLUM: ზუსტად.
ასე რომ, ეს შეიცავს ყველა სასარგებლო ბიტი და ცალი ინფორმაცია
რომ ჩვენ ვსაუბრობთ ადრე.
შემოწმების ფარგლებში dot ჟესტები არის მასივი ჟესტები
რომ ნახტომი მოძრაობის დაიჭირეს თქვენი ხელში აკეთებდა ბოლო ფარგლებში.
ასე მაგალითად, რა ვართ აკეთებს აქ ჩვენ შემოწმების,
hey, Leap, რომ ბოლო ჩარჩო გააკეთა დაჭერა ნებისმიერი ჟესტები, რომ მე?
და თუ ასეა, რა მოგვინდება არის iterate მეშვეობით იმ ჟესტები
და ცდილობენ და მიიღოთ გარკვეული სასარგებლო ინფორმაცია მათგან.
თითოეული ჟესტი აქვს უნიკალური ID მასთან.
მათ აქვთ ტიპის.
თქვენ შეგიძლიათ შეხედოთ რომელიც თითების ჩართული იყო ჟესტები
მიერ შემოწმების out ამ pointable პერსონალი.
ასე რომ, თუ, როდესაც თქვენ გაიაროს Leap Motion JavaScript API პერსონალი,
როდესაც ისინი ვთქვათ pointables, ისინი საუბრობენ ამ თითების.
და შემდეგ ხელში, რა თქმა უნდა, მთელი მხრივ ობიექტი.
>> რა?
თქვენ შეგიძლიათ შეამოწმოთ რამდენად ხანგრძლივი შუამდგომლობა წავიდა
და, yeah, ყველა იმ საჭირო რამ.
ასე, რასაც მე ვაკეთებ ახლა აქ მე შესული ფარგლებში,
და მერე ჩემ HTML ცარიელია ყველა ამ ბიტი ინფორმაციის
ფარგლებში.
მოდით შევამოწმოთ, რომ.
>> ასე რომ, აქ არის.
აი ინდექსი dot HTML ფაილი.
და როგორც უბრალოდ დაინახა, როდესაც მე უბრალოდ გადავიდა ჩემი მხრივ Leap დაიჭირეს წრე მოძრაობაში.
ასე რომ თქვენ ხედავთ me აკეთებს წრე დასრულდა აქ, განახლებები წრე ინფორმაცია.
აკეთებს ჩერდება, იჭერს ჩერდება.
მოდით ვცდილობთ ეკრანზე tab.
იქ ჩვენ წავიდეთ.
ეკრანზე დაარტყით და გასაღები ჩამოსასხმელი.
ასე გასაღები ონკანები ასევე, გზა, როდესაც თქვენ მოხვდა down.
ასე რომ თქვენ წარმოიდგინეთ იქნებ სათამაშო ფორტეპიანო.
>> და შემდეგ ეკრანზე ონკანები როდესაც თქვენ მოხვდა ეკრანზე.
ასე რომ თქვენ წარმოიდგინეთ იქნებ რეალურად აქვს სენსორული თქვენს წინაშე
და თქვენ hitting touch ეკრანზე თქვენს წინაშე.
და მაშინ ჩვენ შეგვიძლია აითვისებდა ერთი ამ ობიექტების აქ.
ასე მახსოვს, მე ვუთხარი, რომ მე გავლის ჩარჩო შევიდა console ჟურნალი.
და ასე შეგვიძლია შეამოწმეთ ყველა ბიტი და ცალი ინფორმაცია
რომ შესაძლებელია რომ ჩარჩო ასევე გამოიყენოს.
>> როგორც ვთქვი ადრე, pointables არიან თითების.
იმ მომენტში, ჩვენ არ გვაქვს ხელები წინ Leap Motion
ასე რომ, ეს არ არის რეგისტრირებული ნულოვანი, მაგრამ ეს არის, თუ როგორ
დაიწყება, რათა გაირკვეს, შესაძლოა, რამდენი თითების ეკრანზე.
და რომ ამ სახის ინფორმაცია.
TOMAS Reimers: და დამახსოვრების ეს არის მხოლოდ ობიექტი.
ასე რომ, ყველაფერი შეიძლება გამოიყენოთ სახის მოსწონს struct
C. თქვენ გაქვთ ობიექტი ასახელებს dot ქონება სახელი.
და შემდეგ შიგნით რომ თქვენ გაქვთ კოლექტორები და თქვენ გაქვთ სხვა ობიექტები,
მაგრამ გვახსოვდეს, რომ ეს მხოლოდ ობიექტი.
იქ არაფერი განსაკუთრებული რადგან ჩვენ გამოყენებით ნახტომი.
Armaghan BEHLUM: ჰო.
მაგარი.
უნდა ჩვენ შეამოწმეთ რამდენიმე of JavaScript მაგალითები?
>> TOMAS Reimers: ასე სწრაფად გვახსოვდეს, რომ ჩვენ
განაცხადა, რომ Leap შეგიძლიათ რეალურად აწარმოებს ნებისმიერი ნახვა.
LeapJS მხოლოდ ემსახურებოდა კლიენტს.
და ასე ერთად, როგორც კლიენტს აქვს Leap Motion ერთვის ის იმუშავებს.
ასე Leap Motion აქვს საიტი, სადაც ადამიანი
შეიძლება თავიანთ მაგალითები რამ ისინი გააკეთა.
ასე რომ, ჩვენ უბრალოდ აპირებს მეშვეობით რამდენიმე მათგანი
ხედავთ რა შეიძლება ადრე diving შევიდა უფრო სპეციფიკა, როგორ
ეს შესაძლებელია.
ასე
Armaghan BEHLUM ვნახოთ.
TOMAS Reimers: ახლა უნდა მუშაობა.
Armaghan BEHLUM: ახლა სანამ ჩვენ ვნახეთ, მაგალითად,
გამოყენებით ერთობა, რომ გაწეული ჩვენს ხელში საკმაოდ შთამბეჭდავი გრაფიკული ტყავი,
მაგრამ ახლა ხედავთ შეგიძლიათ გააკეთოთ იგივე შიგნით ბრაუზერში.
ეს არის ყველა შიგნით Chrome უბრალოდ გამოყენებით JavaScript.
და შემდეგ სხვა ლამაზი საქმე ის არის, რომ, თუ გსურთ
იცით, თუ როგორ აკეთებდნენ ამას, მაგალითები, JavaScript
ასევე მოიცავს კოდი ვარიანტი, რომ თქვენ შეგიძლიათ შეამოწმოთ და მერე ვნახოთ
როგორ იყო ეს ადამიანი grabbing ხელები და კოდები და ასეთი.
>> ასე რომ, ყველა იპოვნით at developer.leapmotion.com.
თქვენ შეგიძლიათ წასვლა და შეამოწმეთ JavaScript მაგალითები, რომ მათ აქვთ იქ.
ასე yeah.
აქ არის ამ, oops sorry.
მოდით ვეცადოთ, რომ კიდევ ერთხელ.
Oh.
მე მაქვს ორი მარჯვენა ხელში.
ასე yeah.
>> TOMAS Reimers: ასე და კიდევ ერთხელ, გვახსოვდეს, ზოგჯერ Leap ერევა up.
უბრალოდ მისცეს მას მეორე.
ეს არ არის სრულყოფილი, მაგრამ ეს არის საკმაოდ კარგი.
Armaghan BEHLUM: One სხვა რეკომენდაციაში ასევე
არის ამის გაკეთება არ პირდაპირი მზის.
ასე რომ გზა Leap Motion სამუშაოები, ფაქტობრივად
თუ მე გაჩვენებთ კამერა ეს ასევე, ინფრაწითელი სინათლის.
ასე რომ აგზავნის იმ და შემდეგ ნათქვამია მათ, როდესაც ისინი ბრუნდებიან.
ასე რომ, თუ თქვენ ცდილობთ ამის გაკეთება პირდაპირი მზის,
მაგალითად, ეს, ალბათ, არ იმუშავებს,
ან ის აპირებს მოითხოვოს ზოგიერთ calibration ამის გაკეთება.
>> კიდევ ერთი რეკომენდაციით, გარკვევა სივრცეში უკან Leap
და წინ ნახტომი.
ვფიქრობ, რომ ეს სამუშაო შიგნით გუმბათი, რომ
მიმდებარე ამ Leap Motion ობიექტი.
თუ არსებობს პერსონალის უფლება უკან, ისევე,
ესეც ჩაერიონ თუ როგორ Leap Motion ცდილობს
აღიაროს თქვენი მხრივ და რომ ამ სახის პერსონალი.
>> ასე, მაგალითად, მე ვფიქრობ, რომ ამ საქმე ის არის ჩემი ლეპტოპი რეალურად
რომ სახის მიღების ნახტომი Motion.
ჰო, იქ ჩვენ წავიდეთ.
ასე რომ, თუ გასარკვევად ჩემი ლეპტოპი მის უკან მხრივ გამოჩნდება კარგად.
ასე yeah.
იქ რომ.
ასე რომ, რა გავაკეთეთ ჩვენ ვაჩვენოთ.
TOMAS Reimers: ვფიქრობ, ახლა იქნება დრო
დასალაგებლად ჩაყვინთვის შევიდა და მოდით, უბრალოდ, რათა დემო სრულიად ნულიდან.
ეს იქნება მართლაც მარტივია.
ძირითადად, რასაც ჩვენ ვაპირებთ ცდილობენ გააკეთოთ ეს
ასე რომ, როდესაც თქვენ დარტყმა თქვენი მხრივ, ფონზე დაწყებას აპირებს out წითელი,
და როდესაც თქვენ დარტყმა თქვენი მხრივ, ფონზე აპირებს გახდეს მწვანე.
OK?
მართლაც მარტივია.
და ეს, ძირითადად, მხოლოდ აპირებს გაიაროს ბევრი
ცნებები უკან ნახტომი ისე, რომ ჩვენ შეგვიძლია
შეღწევას ამ იდეოლოგიის როგორ Leap მუშაობს და როგორ შეგვიძლია ავაშენოთ პერსონალის რომ.
და შემდეგ იქიდან ჩვენ ალბათ უბრალოდ გაჩვენებთ
API Docs და სადაც უფრო მეტი ამ.
და მაშინ ჩვენ მას ყოველდღე.
ასე რომ გსურთ კოდი ან გინდა, რომ კოდი?
Armaghan BEHLUM: ჰო.
ასევე, ვფიქრობ, ჩვენ შეგვიძლია შევიმუშაოთ ერთად ამ და ცდილობენ
>> TOMAS Reimers: ასე ჩვენ დაკავდით წყვილი კოდირება.
Armaghan BEHLUM: იქ ჩვენ წავიდეთ.
ეს არის ზუსტად ის, რაც მე სურდა შეამოწმეთ.
მაგარი.
ასე მაგალითად აქ, ვნახოთ.
მიუხედავად იმისა, რომ ჩვენ iterating მეშვეობით ჟესტები უკვე,
TOMAS Reimers: მინდა უბრალოდ სრულიად ახალი ფაილი?
Armaghan BEHLUM: სრულიად ახალი ფაილი?
ჰო, რა თქმა უნდა.
>> TOMAS Reimers: ჰო.
>> Armaghan BEHLUM: მოდით გავაკეთოთ, რომ.
>> TOMAS Reimers: ამიტომ, ჩვენ ვაპირებთ რათა სრულიად შეიტანოს.
ჩვენ მოვუწოდებთ მას გადასცემს dot HTML.
რომ არის მაგარი ჩემთან ერთად.
ასე მახსოვს, რომ თქვენ ამის HTML tag, შემდეგ შიგნით რომ თქვენ გაქვთ ხელმძღვანელი.
რომ ხელმძღვანელი ჰყავს სათაური ფარგლებში.
ასე tab სხვა გზით.
იქ წასვლა.
სათაური, ჩვენ მოვუწოდებთ მას ნახტომი მაგალითი.
Yep.
>> Armaghan BEHLUM: Oops.
სათაური.
>> TOMAS Reimers: Yep.
>> Armaghan BEHLUM: არ ვართ.
>> TOMAS Reimers: და მაშინ მოდით მიიღოს ორგანო.
>> Armaghan BEHLUM: დაველოდოთ, მოდით ასევე დარწმუნდით იმპორტი.
TOMAS Reimers: Oh, რა თქმა უნდა.
ჩემი ცუდი.
ამიტომ ყოველთვის დარწმუნდით, რომ თქვენ გაქვთ Leap script ასე რომ დამწერლობის გადაეცა თქვენ
by Leap Motion, რომელიც ძირითადად საშუალებას ბრაუზერში დაკავშირება
to მოწყობილობის შესახებ კომპიუტერში.
და შემდეგ ამ ჩვენ ასევე საჭიროა სხეულის და მოდით, უბრალოდ,
რათა ორგანოში აცხადებენ, hi ასე რომ ჩვენ შეგვიძლია ვაჩვენოთ სტუდენტები
როგორ დაკავშირება ამ ახალი ვებ გვერდზე, რომელიც მათ გააკეთეს.
Armaghan BEHLUM: რა თქმა უნდა.
მოდით უბრალოდ დააყენა another--
>> TOMAS Reimers: Hi, Hello World.
ასე რომ, ძალიან ძირითადი მაგალითი.
მართლაც მხოლოდ დემო.
>> Armaghan BEHLUM: და მერე აქ ჩვენ შეგიძლიათ წასვლა, ჩვენ მას ხელი dot HTML,
არა?
და oh!
ამიტომ მაინტერესებს, რა არის არასწორი ამ წუთას.
მოდით დაამატოთ წაკითხულად ნებართვების გადასცემს dot HTML.
TOMAS Reimers: გსურთ ამის გაკეთება დიდი ტერმინალი
ასე რომ ჩვენ შეგვიძლია მხოლოდ აჩვენებს, the--
>> Armaghan BEHLUM: Yeah, რომ აზრი.
ყველა უფლება.
ასე რომ, მე უბრალოდ დასძინა უფლებები, მაგრამ თუ ჩვენ
იყო შეამოწმეთ ნებართვების სანამ ჩვენ
არ ჩანს, რომ რეალურად ხელი dot HTML არ აქვს წაკითხული უფლებები
და, შესაბამისად, ჩვენ ვერ გაუწიოს მას.
მაგრამ ახლა, თუ ასე მოვიქცევით, ჩვენ ვხედავთ, ჩვენი პატარა hello world უფლება არსებობს.
>> TOMAS Reimers: მოდით რეალურად, როგორც ის წერდა, hello world,
მე მიფიქრია გზა ჩვენ შეგვიძლია შევცვალოთ ეს.
მოდით ეს მიესალმები მსოფლიოში, და მაშინ, როდესაც თქვენ ტალღა, ის აცხადებს, რომ მშვიდობით.
არა?
ასე hello, მშვიდობით.
>> Armaghan BEHLUM: რა თქმა უნდა.
>> TOMAS Reimers: ეს ხმები საკმაოდ კარგი.
>> Armaghan BEHLUM: ეს ხმები კარგი ჩემთვის, ძალიან.
>> TOMAS Reimers: ასე რომ, თუ ჩვენ ვაპირებთ, რომ მოდით, უბრალოდ,
ვფიქრობ მეშვეობით ვებ გვერდზე ცოტა.
ჩვენ ვაპირებთ, რომ საჭიროა გარკვეული script რომელიც ძირითადად არეგისტრირებს
რომ თქვენ შეარხია და ნახტომი, ტალღა და დარტყმა, იგივე.
ასე რომ, ჩვენ ვაპირებთ უნდა სცენარი, რომ ძირითადად რეგისტრაციას, რომ დარტყმა.
და კიდევ ერთი რამ, რომ ჩვენ ვართ ვაპირებთ გვჭირდება ჩვენ
სჭირდება გარკვეული ფაქტობრივი შინაარსი შეცვალოს.
>> ასე რომ, როგორც გახსოვთ, jQuery გაძლევთ საშუალებას შეცვალოთ შინაარსი.
ასე ერთი რამ ჩვენ დაგვჭირდება მოიცავს ამ არის jQuery ბიბლიოთეკა.
და შემდეგ შეძლებთ აირჩიოთ რა ჩვენ რეალურად შეიცვლება შინაარსი,
რომ აპირებს უნდა ID ან კლასის, ან რამე
რომ ჩვენ შეგვიძლია გამოვიყენოთ შესარჩევად მას.
ასე რომ, ჩვენ მხოლოდ მისთვის სწრაფი ID ცვლილების ტექსტი.
და მერე გვინდა, რომ დაიბრუნოს jQuery?
Armaghan BEHLUM: რა არის პირველი რამ ჩვენს გავაკეთოთ სია, მაშინ ახლა?
TOMAS Reimers მოდით დაიბრუნოს jQuery?
Armaghan BEHLUM მოდით დაიბრუნოს jQuery, OK, მაგარი.
იმ შემთხვევაში, მე ვაპირებ უნდა რეალურად
სადაც იქნება საუკეთესო ადგილი ამის გაკეთება?
>> TOMAS Reimers: jQuery, ასე რომ, თუ თქვენ Google jQuery, მოხვდა jQuery, პირველი
Armaghan BEHLUM: ძალიან პირველი.
TOMAS Reimers: ან download.
ეს ჯარიმა.
Hit ჩამოტვირთვა v1 და v2 მარცხენა.
ასე რომ, ჩვენ აღწერს, jQuery საწყისი ამჟამად, როგორც თქვენ ალბათ გაკეთდეს.
გადახვევა down.
Up, up.
>> Armaghan BEHLUM: Oh, სწორედ აქ არის?
TOMAS Reimers: ან რომ.
Yep.
ასე jQuery აქვს უმასპინძლა ვერსია რაც იმას ნიშნავს, რომ თქვენ არ რეალურად
უნდა გადმოწეროთ, მაგრამ თქვენ უფრო მეტი, ვიდრე
მივესალმებით გადმოწეროთ და უმასპინძლებს იგი საკუთარ თავს.
Armaghan BEHLUM: Cool.
ახლა ჩვენ გვაქვს jQuery.
ახლა, რა მომავალი ჩვენს გავაკეთოთ სია.
TOMAS Reimers: გასაოცარია.
ასე რომ, მომავალი, რაც ჩვენ გვჭირდება ამის გაკეთებას, ჩვენ რეალურად უნდა
მისცეს p hello world ID ასე რომ ჩვენ შეგვიძლია ეს, არა?
მოდით მივცეთ იდეა, მე არ ვიცი, შეცვალოს ტექსტი?
Armaghan BEHLUM: მოდით უბრალოდ იგი ამ გზით, ვფიქრობ.
TOMAS Reimers: changeText, ზემოთ.
და ახლა მოდით უბრალოდ ცარიელია გვერდზე.
დარწმუნდით, რომ ყველაფერი სამუშაოები.
ასე უკან ბრაუზერში.
მაგარი.
ყოველთვის კარგი შეხსენება, რომ როდესაც თქვენ აშენებს ნახვა,
ალბათ ცარიელია ყოველ დროს, თქვენ მიიღოს ნებისმიერი გარკვეულწილად მნიშვნელოვანი ცვლილება მხოლოდ
რადგან ზოგჯერ შემთხვევით ჩამოაგდეს tag,
ან თქვენ შემთხვევით წაშალეთ რაიმე, და მაშინ შესვენება რაღაც პატარა,
მაგრამ მაშინ, როდესაც თქვენ დიდი ცვლილება თქვენ, როგორიცაა, რატომ ეს დიდი ცვლილება
როგორც ჩანს, დაარღვიოს unrelated რამ.
ასე რომ ის ყოველთვის კარგი დასალაგებლად წასვლა და იმ საღი აზრის ამოწმებს.
>> მაინც ასე რომ, ახლა მოდით ერთი ბოლო საღი აზრის შემოწმება,
რომელიც მოდით ცდილობენ შეცვლა ტექსტის გარეშე Leap Motion,
გარეშე არაფერი, უბრალოდ გვერდზე დატვირთვის ის ყველაფერს
შეცვლა hello world to მშვიდობით გამოყენებით jQuery.
ასე რომ, თუ გახსოვთ jQuery კარგად ჩანს ეს დოლარის ნიშანი ფუნქცია,
რომელიც ჩვენ შეგვიძლია გაივლის CSS არჩევის, კერძოდ hashtag ცვლილება ტექსტი, რომელიც
ირჩევს ელემენტს ID ცვლილების ტექსტი.
და მაშინ ჩვენ ვაპირებთ მოვუწოდებთ საშუალებას HTML
ობიექტის ის ბრუნდება არგუმენტი სიმებიანი მშვიდობით, რომელიც
შეიცვლება ნივთები HTML ვთქვა მშვიდობით.
გასაოცარია.
რომ, როგორც ჩანს, საკმაოდ გრილი.
და ახლა, როდესაც ჩვენ განახლება გვერდის ჩვენ ვაპირებთ,
ის მომენტალურად ცვლის მშვიდობით, არა?
იმიტომ, რომ ეს არ დაველოდოთ არაფერი.
სახის როგორც კი script გადის ის ცვლის მას მშვიდობით.
მაგარი.
>> ახლა მოდით გადაიტანოთ რომ ფუნქცია.
უფლება.
ასე რომ, ჩვენ ვაპირებთ, რომ გსურთ რათა ფუნქცია.
ჩვენ მოვუწოდებთ მას მშვიდობით.
ასე ფუნქციის მშვიდობით არის აპირებს არანაირი არგუმენტი
და ეს არ არის ნამდვილად დაბრუნებას აპირებს არაფერი.
და ეს მხოლოდ აპირებს გავაკეთოთ, რომ JavaScript.
შესანიშნავი.
ასე რომ, ჩვენი ფუნქცია მშვიდობით ახლა ცვლის ტექსტი მშვიდობით, არა?
ასე რომ, ეს გვაძლევს გზა რომ ძირითადად ცვლილება
რომ ტექსტი მშვიდობით, როცა ჩვენ მოუწოდა, რომ ფუნქცია.
არა?
ასე რომ, ეს არის საკმაოდ გრილი.
>> Armaghan BEHLUM: ჩვენ, ასევე შეგიძლიათ უბრალოდ დარწმუნდით
რომ ახლა, რადგან ჩვენ არ მოუწოდებდა ფუნქცია, თუ ჩვენ ამოცნობა გვერდზე,
შეამჩნია, რომ ის არ აპირებს შეცვალოს ტექსტი.
>> TOMAS Reimers: Excellent.
ახლა ჩვენ ვაპირებთ დავიწყოთ შეღწევას, რომ ნახტომი პერსონალი
რომ ჩვენ ვსაუბრობთ.
ასე Armi, თუ თქვენ გსურთ მას აქედან ან?
>> Armaghan BEHLUM: ჰო.
დარწმუნებული ვარ.
მე ალბათ აპირებს უნდა ორმაგი შემოწმება რამ,
მაგრამ, მაგალითად, მახსოვს, ჩვენ ვთქვით, რომ ჩვენ გვინდოდა
დავრწმუნდეთ, პარამეტრები ჩვენ დავსახეთ საშუალებას ჟესტები
TOMAS Reimers: კარგი დაჭერა.
Armaghan BEHLUM: უნდა იყოს ჭეშმარიტი.
და შემდეგ ჩვენ რეკომენდაციას რომ თქვენ ბიჭები გვინდა
აწარმოებს ნახტომი dot loop, რომელიც როგორც ჩვენ განაცხადა ადრე,
აქვს ორი ვარიანტი, JSON ობიექტი, რომელიც არის ვარიანტი, თუ როგორ გსურთ
კონფიგურაციის Leap Motion to მუშაობა, და შემდეგ ფუნქცია რომ
აპირებს დაჭერა ფარგლებში, როგორც გადმორეკე ფუნქცია, როგორიცაა Tomas ამბობდა.
და შემდეგ შეცვალონ რა გსურთ უნდა გავაკეთოთ, რომ ფუნქცია.
>> ასე რომ, ჩვენ გაივლის ვარიანტი და ახლა ჩვენ განსაზღვრავს
ფუნქცია, რომელიც მიიღებს ფარგლებში.
და ახლა ჩვენ უნდა განსაზღვროს რა, რომ ფუნქცია აქვს.
ეს ასევე გულისთვის მომავალში, გავაკეთოთ, რომ დავრწმუნდეთ.
TOMAS Reimers: Excellent.
ახლა ჩვენ გვაქვს ეს ნახტომი dot loop ფუნქცია
დარეკეთ რომლებიც ძირითადად ნათქვამია დაათვალიერეს Leap ამ პარამეტრების და ყოველ ჯერზე
რაღაც ცვლილებები, დარეკეთ ამ ფუნქცია ფარგლებში ყველა მონაცემები
რომ იცის, თუ რა ფარგლებში.
ჟღერს საკმაოდ კარგი.
ასე რომ, ახლა სწრაფი საღი აზრის შემოწმება, რომელიც მე ყოველთვის რეკომენდაციას,
არის, რომ უბრალოდ დააყენა console dot log ფარგლებში.
და შემდეგ Chrome გახსნათ იგი up და შევხედოთ თქვენი კონსოლი
და ითამაშოს გარშემო Leap ვხედავ ფარგლებში მიმდინარეობს ხართ იმიტომ, რომ
მიიღეთ იდეა რა მონაცემები, რომ თქვენ გაქვთ.
და როგორც ყოველთვის, თუ დაბნეული, ეძებოთ API მითითება.
და ჩვენ მოიცავს ბმული რომ ბოლოს ეს.
>> Armaghan BEHLUM: ასე რომ, ჩვენ ამოცნობა გვერდი და შემდეგ
ჩვენ წავიდეს და გახსენით კონსოლი ერთხელ.
და ახლა ჩვენ შეამჩნია, რომ ჩვენ რომელსაც ფარგლებში გავიდა,
ამ პატარა ობიექტები ჩვენ ვნახეთ ადრე.
ასე yeah.
ეს არის ჩვენი ფარგლებში აჩვენებს up კონსოლი.
მაგარი.
>> ასე, რომ ახლა ჩვენ მოგვეწონა ფარგლებში, როგორც თქვენ ალბათ გახსოვთ, ადრე
მაგალითიდან, რომ ჩვენ გვქონდა, თუ ჩვენ შეამოწმოს ფარგლებში dot ჟესტები
მივიღებთ სია ჟესტები, რომ ჩარჩო ყველაზე ცოტა ხნის წინ დაიჭირეს.
ჩვენ შეგვიძლია შევამოწმოთ სიგრძეზე რომ მასივი ვნახოთ, თუ Leap დაიჭირეს ნებისმიერი ჟესტები.
ასე რომ, თუ მასივი მეტი ნულოვანი, მაშინ ჩვენ
ვიცი, რომ ჩვენ გვაქვს გარკვეული პერსონალი უნდა გააკეთოს.
>> ასე რომ, მოდით გადატანა, რომ წელს თუ მდგომარეობა და ახლა აქ რაც ჩვენ ვიცით, რომ ჩვენ
მინახავს ჟესტი, მოდით იმოქმედოს მასზე.
ასე რომ, ახლა, რომ ჩვენ აქ ჩვენ აქვს ჟესტი შეამოწმეთ.
TOMAS Reimers: ისე, პირველი საქმე ის არის, რომ ეს არ არის მხოლოდ ერთი ჟესტი,
ეს შეიძლება იყოს, როგორც ბევრი ჟესტები.
>> Armaghan BEHLUM: ძალიან ჭეშმარიტი.
TOMAS Reimers: So პოსტი კლასიკური C სტილი აქ
ჩვენ ალბათ გინდათ გამოიყენოთ for loop.
Armaghan BEHLUM: ჩვენ აქ ვართ შემდეგ.
ჩვენ გადავწყვიტეთ, რომ iterate მეშვეობით ჟესტები.
და ვნახოთ.
i plus, plus.
და ახლა თუ ჩვენ შესაძლოა გააკეთა უბრალოდ var ჟესტი ტოლია
ჩარჩო dot ჟესტები bracket i, ახლა გვაქვს
ჟესტი თავისთავად, რომელიც მხოლოდ ერთი ერთი შემთხვევა ჟესტი ობიექტი
ჩვენთვის მუშაობა შიგნით ამ loop.
ყველა უფლება.
TOMAS Reimers: მოდით საღი აზრის შეამოწმეთ აქ ერთხელ და მხოლოდ ნუგეშია
dot შეხვიდეთ ჟესტი ვნახოთ, რა მივიღებთ.
>> Armaghan BEHLUM: Console dot log ჟესტი.
Okie dokie.
და ამოცნობა კიდევ ერთხელ.
>> TOMAS Reimers: მოდით სცადეთ მიღების ჟესტი.
დაინახავთ, რომ bunch საქართველოს, როდესაც მან swipes,
თქვენ მიიღებთ რამოდენიმე ჟესტები console და თუ იგი ცდილობს გააკეთოს წრე,
ეს just--
>> Armaghan BEHLUM: Circles უბრალოდ მართლა ლამაზი.
>> TOMAS Reimers: ახლა არის უცნაური რამ აქ, რომელიც აკეთებს ერთი წრე,
მაგრამ ეს არ არის ხე 80 ჟესტები, უფლება?
რომ ბევრი ჟესტები.
ასე რომ, პირველი სახის რამ გააცნობიეროს, და ეს შეიძლება იყოს დამაბნეველი,
არის ის, რომ ჟესტი არ არის უბრალოდ შესული ერთხელ.
>> ყველა ჩარჩო, მარჯვენა, ასე რომ, თუ მე ვაკეთებ წრე
ნახტომი აღმოაჩინოს ამ ცვლილება, ამ
ცვლილება, ამ ცვლილება.
და ეს იქნება შეხვიდეთ ყოველ ერთ იმ.
მაგრამ ყოველი ერთი იმ, ის აპირებს თქვათ,
არსებობს ჟესტი ამჟამად მიმდინარეობს.
ნება მომეცით, უბრალოდ, ვამბობთ, hey, არსებობს ჟესტი და ეს ამჟამად მიმდინარეობს.
ასე რომ, ჩვენ არ გვინდა არ არის ამბობენ, oh, ყოველ ერთ
იმ ჟესტები თქვენ მინდა, რომ შეიცვალოს ტექსტი.
რა გვინდა გავაკეთოთ არის ის, როდესაც, რომ ჟესტი შეწყვეტს, და ჩვენ შეგვიძლია შევამოწმოთ, რომ
მაშინ ჩვენ გვინდა, რომ შეიცვალოს ტექსტი.
Armaghan BEHLUM: mhmm.
ასე რომ, როგორც Tomas არის აეხსნა ამ ჟესტები
შესაძლოა, როგორც ჩანს მეშვეობით სხვადასხვა ფარგლებში, მაგრამ მაგალითად,
როდესაც ჩვენ მქონე რომ წრე, ჩვენ ვხედავთ,
რომ ID, რომ ერთი ერთი წრე, რომ ჩვენ
შესაძლოა, უკვე ცდილობს დაასრულოს იყო იგივე ID მასშტაბით.
და სინამდვილეში, ასევე შეგიძლიათ შეამოწმეთ სტატუსი.
ქ.
>> და მაშინ ეს, ალბათ, ბოლო წრე, რომელიც, oh, ასევე, OK.
ზოგჯერ ის გიჩვენებთ სტატუსი შეჩერების ჟესტი
და ასევე გიჩვენებთ სტატუსი დაწყებული ახალი ჟესტი, როდესაც
ის აღიარებს, რომ ჯერ თქვენ დაიწყო ახალი ჟესტი.
მაგალითად, ამ შემთხვევაში.
TOMAS Reimers: Cool.
Armaghan BEHLUM: ასე yeah.
და შემდეგ, ვნახოთ.
ასევე, შეგიძლიათ შეამჩნია მიუხედავად იმისა, რომ ჩვენ მიღების
წრე და ჟესტი აქვს სფეროში მოუწოდა ტიპი
რომელიც გვეუბნება, თუ რა სახის ჟესტი, რომ არის.
ასე რომ, შეიძლება სასარგებლო იყოს ჩვენთვის თქვენ ცდილობენ და რა ვაკეთებთ.
TOMAS Reimers: ასე გადასვლის უკან JS,
პირველი, რაც ხდება ჩემთვის, ასევე, უბრალოდ კითხულობს ეს კოდი
აქ არის პატარა ოპტიმიზაცია, რაც ჩვენ რეალურად
არ უნდა, თუ მდგომარეობა, არა?
იმიტომ, რომ თუ ჩარჩო dot ჟესტები dot სიგრძე არის ნულოვანი, რომ მარყუჟი მიერ
არ აპირებს მაინც.
ასე რომ, ჩვენ შეიძლება ასევე მხოლოდ წავიდეთ წინ და დავაღწიოთ.
ერთხელ, ხოლო თქვენ წერა კოდი მნიშვნელოვანია, რომ დაბრუნდეს და სახის
of refactor როგორც ხვდები, რომ თქვენ შეიძლება გაკეთდეს რაღაც უკეთესი,
ან არსებობს სხვა გზა უნდა გააკეთოს, რომ.
ასე რომ, ახლა ჩვენ უბრალოდ აპირებს გაწმენდა ამ up სწრაფად და ასევე გაწმენდა თქვენი კოდი.
ეს არის დიდი გარიგება.
>> Armaghan BEHLUM: Good სტილი ძალიან დასაფასებელია.
>> TOMAS Reimers: თქვენ შეგიძლიათ ყოველთვის ვუთხრა, როცა ვინმე
აქვს კოდი, სადაც არ უნდა იყოს, თუ მდგომარეობა და შემდეგ ისინი ამოიღეს ეს,
მაგრამ ისინი არ uncomment იგი.
ეს არის ძალიან ნათელი და ეს ერთგვარი გამოიყურება მახინჯი.
Armaghan BEHLUM: რა არის შემდეგი ჩვენს გავაკეთოთ სია?
TOMAS Reimers: ახლა, როგორც ჩვენ ვამბობდით, ვფიქრობ, პირველი, რაც ჩვენ გვინდა, რომ
არის დავრწმუნდეთ, რომ ჟესტი მიერ რეალურად დარტყმა, არა?
>> Armaghan BEHLUM: ჰო.
>> TOMAS Reimers: ასე რომ, თუ ჩვენ ვამბობთ, რომ ჩვენი მშვიდობით სახის როგორც დარტყმა,
ჩვენ წავიდეთ ერთად ეს დარტყმა, პირველი, რაც უნდა ვთქვა, ის არის, hey,
არის ჟესტი ტიპის დარტყმა, არა?
არ არის წრე ან დაბრუნება, მაგრამ ეს დარტყმა?
ასე რომ, შეგვიძლია გავაკეთოთ, რომ არის, ჩვენ შეგვიძლია ვთქვათ ჟესტი
dot ტიპის თანაბარი თანაბარი დარტყმა როგორც სიმებიანი.
>> Armaghan BEHLUM: [INAUDIBLE] ჟესტი dot ტიპის უდრის უდრის დარტყმა.
არსებობს ვართ.
>> TOMAS Reimers: და შემდეგ ბოლო კითხვა
ჩვენ გვინდა, რომ ეს ჟესტი dot სახელმწიფო თანაბარი თანაბარი გაჩერება, არა?
ასე რომ, როდესაც ჟესტი უკვე შეწყდა.
მე რეალურად ვფიქრობ, დარტყმა, I ვიცი, რომ ეს off ზევით ჩემი უფროსი,
მაგრამ თქვენ მივესალმებით გამოიყურება ის, როდესაც თქვენ
დარტყმა ყოველ ჯერზე ეს რეგისტრაციაში სანამ შეჩერება არის დაწყება ჟესტი.
და შემდეგ ბოლო ერთი მხოლოდ stop ჟესტი.
ასე რომ არ უნდა იყოს მხოლოდ ერთი გაჩერება ჟესტი, რომელიც დიდი ჩვენთვის.
რა შეგვიძლია გავაკეთოთ არის ამბობენ, თუ ჟესტი dot ჩაწერეთ თანაბარი თანაბარი დარტყმა და ჟესტი dot
სტატუსი თანაბარი თანაბარი შეჩერება, მაშინ მოდით საღი აზრის
შეამოწმეთ აქ ნუგეშია dot log ჟესტი.
>> ასე რომ, ჩვენ დავბრუნდებით აქ.
ჩვენ ამოცნობა გვერდზე.
და ახლა მხოლოდ დროის რაღაც უნდა იყოს console dot შესული, როდესაც ჩვენ დარტყმა.
და ჩვენ ვცდილობთ დარტყმა და ჩვენ ვხედავთ, არაფერი.
არა?
ასე რომ, ეს არის რეალურად დიდი საკითხი.
ჩვენ ვერ ვხედავთ, რასაც ჩვენ ველოდით, რომ.
და გამართვის შეიძლება დიდი ნაწილი.
ასე რომ, პირველი, რაც ჩვენ ვაპირებთ ვთქვა, OK, მოდით ნუგეშია dot
შეხვიდეთ თუ ჟესტი dot ჩაწერეთ თანაბარი თანაბარი დარტყმა.
Armaghan BEHLUM: ჰო, მოდით გავაკეთოთ, რომ.
TOMAS Reimers: ასე რომ, ჩვენ ვაპირებ დავუბრუნდე ამ.
ჩვენ ამოცნობა.
ჩვენ უნდა დარტყმა.
და ჩვენ ვაპირებთ, რამოდენიმე მათგანი.
OK.
ამგვარად, პრობლემა ის იყო, ჩვენი ჟესტი dot სტატუსი.
ასე რომ, თუ ჩვენ გახსენით ერთი ასეთი ჩვენ გამოგიგზავნით გამოიყურება ობიექტები და ვნახავთ,
ასევე, ეს გაჩერება, მაგრამ, oh, ეს ე.წ. სახელმწიფო, არ სტატუსი.
ასე რომ, თუ ჩვენ უხელმძღვანელებს უკან ჩვენს კოდი ჩვენ შეგვიძლია ვთქვათ,
თუ ჟესტი dot ტიპის თანაბარი თანაბარი დარტყმა და ჟესტი dot სახელმწიფო თანაბარი თანაბარი გაჩერება,
მაშინ ჩვენ გამოგიგზავნით ნუგეშია dot შეხვიდეთ.
და ასე ამოცნობა.
ჩვენ დარტყმა.
და ჩვენ დავინახავთ, რომ ყველა დარტყმა, ჩვენ მხოლოდ
მიღების ერთი, რომელიც არის დასასრულს, რომელიც დიდი, არა?
ეს არის ის, რაც ჩვენ გვინდა.
>> Armaghan BEHLUM: Yep.
და ჩვენ შეგვიძლია ასევე შეამჩნევთ, რომ ახალი პირადობის მოწმობა თითოეული ეს ჟესტები ცალკე.
ისე, Tomas ამბობდა იმიტომ, რომ ჩვენ catching ამ ერთი გაჩერების აცხადებენ, რომ
არსებობს ბოლოს დარტყმა, ჩვენ მიღების ინდივიდუალური ცალკე ჟესტები
ნახტომის Motion.
დიდი.
>> TOMAS Reimers მოდით წავიდეთ წინ და მხოლოდ ამის საბოლოო რამ, რაც არის,
>> Armaghan BEHLUM: Goodbye.
>> TOMAS Reimers: გასაოცარია.
და ახლა მოდით შეამოწმეთ ჩვენი ნახვა.
ერთი
>> Armaghan BEHLUM: მეორე.
ჩვენ არ, yeah, ჩვენ არ ეძახით Goodbye.
დიდი.
>> TOMAS Reimers: არა, Goodbye არის რეალური ფუნქცია.
>> Armaghan BEHLUM: ჰო.
მოდით გავაკეთოთ, რომ.
>> TOMAS Reimers: და როდესაც ჩვენ დაუქნევენ, იგი აცხადებს, რომ მშვიდობით.
>> Armaghan BEHLUM: ჩვენ გვაქვს გამარჯვება.
>> TOMAS Reimers: ასე რომ, საკმაოდ საინტერესო პერსონალი.
იმედია შეგიძლიათ აშენება რაღაც სხვაგან, მაგრამ თქვენ მიიღებთ იდეა, არა?
თქვენ შეუძლია აღმოაჩინოს ჟესტები.
შეგიძლიათ დარეკოთ ფუნქციები.
და, რომ მართლაც გაძლევთ ზოგიერთი ძალიან ფუნდამენტური შენობა ბლოკები
სათქმელია, რა, იქნებ მაშინ, როცა ისინი დარტყმა up, იმიტომ, რომ თქვენ ასევე შეუძლია აღმოაჩინოს რამ
როგორიცაა მიმართულებით.
მინდა მათ რამე.
ან როდესაც ისინი დარტყმა უფლება, მე მინდა მათ რამე.
და ჩვენ შეგვიძლია დავიწყოთ მისაღებად შემოქმედებითი როგორ ზუსტად
ჩვენ ვაპირებთ, რომ გავაუმჯობესოთ ნახვა გამოყენებით ამ დარტყმა ჟესტები ან წრე
ჟესტები, ან სტეპის ჟესტები, ან გასაღები ონკანები ან ეკრანზე ონკანები.
და მაშინ, გარდა, რომ თქვენ მეტი მივესალმებით ითამაშოს
ფაქტობრივი მონაცემები, მაგრამ თუ თქვენ გსურთ,
ის, რომ ჩვენ გთავაზობთ წასვლა Docs იმიტომ, რომ ისინი რეალურად კარგი.
ასე გაემგზავრა docs ახლა.
ან გინდა გაიგო, რომ?
>> Armaghan BEHLUM: ჰო.
მოდით გავაკეთოთ, რომ.
ასევე კიდევ ერთი tidbit რჩევა, არ ცდილობენ და ვფიქრობ, ამ 3D.
ასე რომ, რეალურად მოდით დახევის up იმ ჟესტები კიდევ ერთხელ console dot log ჟესტი
და ჩვენ გაგვაჩნია.
დავბრუნდებით და ახლა მოდით შევეცადოთ რამდენიმე ამ, რამდენიმე იმ.
>> თუ ჩვენ წავიდეთ და შეამოწმეთ ამ ჟესტები ასევე
როგორც ხედავთ, რომ ისინი dimensionality
არის სამი მიმართულებით, რეალურად.
ასე არა მარტო ზღუდავს თავს 2D ეკრანზე
მიუხედავად იმისა, რომ თქვენ შეიძლება იყოს 2D ნახვა.
შეგიძლიათ ცდილობენ და ვფიქრობ, როგორ შესახებ შეიძლება ურთიერთქმედება ნახვა 3D.
TOMAS Reimers: In 3D სივრცეში.
Armaghan BEHLUM: ზუსტად.
და ჰო.
ასე რომ თქვენ მიმართულებით, velocities, ყველა ეს მაგარი ბიტი ინფორმაცია.
>> TOMAS Reimers: და, თუ თქვენ არ იცნობს, რომ, ის მიდის x, y,
და შემდეგ z არის ამ ბოლო განზომილება.
უბრალოდ რაღაც, რომელიც, ალბათ, იცნობს თუ თქვენ განხილული 3D
კოორდინაცია თვითმფრინავები ადრე.
თუ თქვენ არა გაქვთ, ეს არის იგივე როგორც 2D ერთ გარდა არსებობს მესამე განზომილება.
ჩვენ მოვუწოდებთ მას z.
და ყველაფერი, სახის მოსწონს მიმართულება, რომელიც, სადაც ეს ხდება,
position-- მე ვფიქრობ, რომ, შესაძლოა, გამოვლენა დაჩქარება, მე არ ვარ დარწმუნებული.
>> Armaghan BEHLUM: ჰო, მე მჯერა.
ეს ნამდვილად აქვს სიჩქარე.
მე რეალურად არ არის 100% დარწმუნებული შესახებ დაჩქარება.
>> TOMAS Reimers: ეს შეიძლება იყოს ვარიანტი თქვენ შეგიძლიათ გადავიდნენ რაღაც.
ასე პოზიცია და სიჩქარე ექვემდებარებიან ამ სახის სამი კოორდინატები.
ასე x, y, z, ან delta x, დელტა y, delta z.
ასე რომ, ახლა გაემგზავრა დოკუმენტაცია ეს developer.leapmotion.com
და შემდეგ თქვენ შეგიძლიათ დააჭიროთ დოკუმენტაცია.
ერთხელ, Leap Motion აქვს ყველა ეს მშვენიერი APIs, ერთი JavaScript,
ერთი C Sharp და ერთობა, ერთი C ++, ერთი Java, ერთი Python,
და ერთი მიზანი C. მე პირადად დააყენებს თქვენ მიმართ JavaScript
ან თუ გსურთ ისწავლოს ახალი ენა, ცდილობენ Python.
ორივე იმ ენებზე მე მუშაობდა ადრე და ისინი მართლაც ადვილად სწავლობენ
და თქვენ უკვე იცით JavaScript, რომელიც რაც ნამდვილად კარგი კანდიდატი.
>> ერთი სიტყვა სიფრთხილით როდესაც შედიხარ Docs.
დარწმუნდით, რომ თქვენ Docs v2.0.
იმიტომ, რომ, თუ თქვენ ერთი ვერსია, რომ ეს არ იმუშავებს.
ასევე მაგალითად გალერეა.
გავატარეთ კარგი 30 წუთი ცდილობს გამართვის ჩვენი Leap
სანამ ჩვენ მიხვდა, რომ V1 არ მუშაობს V2.
ასე რომ მხოლოდ დარწმუნდით თქვენ ორი ვერსია.
და მაშინ მე მისცეს აჩვენოს თქვენი Docs.
Armaghan BEHLUM: ჰო.
ასე რომ აქ API მიმოხილვა და შემდეგ ზოგი ბიტი და ცალი ინფორმაცია
რომ ჩვენ უკვე მოგახსენეთ.
ლამაზი პატარა მცურავი ხელები მაღლა Leap Motion.
და შეხსენება, ვფიქრობ, სივრცეში 3D.
ერთ-ერთი პირველი ობიექტების ვიფიქროთ ერთად Leap Motion არის პრაქტიკული, რა თქმა უნდა.
ჩვენ ვნახეთ იმ აღიარებულ მიერ Visualizer.
და მაშინ ალბათ ჩანს, რომ იგი აღიარებულია
ნაწილი მაჯის და მკლავი ასოცირდება იგი.
TOMAS Reimers: თუ გსურთ დახევის up Visualizer.
Armaghan BEHLUM: ჰო, მოდით გავაკეთოთ, რომ კიდევ ერთხელ.
TOMAS Reimers: თქვენ ხედავთ, ყოველთვის უბრალოდ კარგი შეხსენება ერთგვარი ვხედავთ,
Visualizer ცდილობს აჩვენოს, ყველა მონაცემი, რომელიც Leap ხედავს.
ასე რომ თქვენ დაინახავთ, რომ ჩვენ გვაქვს ამ სახის ოთხი ქულა
მაჯის და მერე რეალურ მაჯის.
თქვენ ასევე გაქვთ ამ ბურთს პალმის.
ყველა ეს რაოდენობა აღიარებს აღიარებული ნახტომი.
>> Armaghan BEHLUM: ზუსტად.
და ასე რომ ხელი ობიექტი თითოეული ფარგლებში ხელი აქვს მასივი
ასევე, სადაც თქვენ ასევე შეგიძლიათ მიიღოთ მარცხენა და მარჯვენა ხელში.
თქვენ შეგიძლიათ მიიღოთ რომელიც მიმართულებით ხელში
წინაშე ნორმალური მიმართულებით პალმის,
ან როგორც ისინი უწოდებენ პალმის ნორმალური.
სხვა რა გვაქვს?
ჩვენ ასევე, oops.
მოდით ცდილობენ და გადახვევა ქვემოთ ამ გზით.
იარაღი, თითები წარმოდგენილია finger
კლასი, რომელიც არის pointable ობიექტი.
ასე რომ, როგორც ჩვენ ვამბობდით, დავინახეთ, რომ მასივი pointables ყოველ მხრივ.
ესენი არიან პატარა თითების ფიქრი.
ასე რომ, ეს არის კარგი მიმოხილვა წასვლა მეშვეობით ცდილობენ და მესმის.
TOMAS Reimers: [INAUDIBLE] ხელის ანატომია up there.
Armaghan BEHLUM: ჰო, ზუსტად.
ასე yeah.
არსებობს უამრავი ნედლეული მონაცემები, რომ Leap Motion იღებს ხსნის კარგად
თქვენ, ასე რომ ის დიდი იდეა გავლა აქ
და ცდილობენ და გაერკვნენ, თუ როგორ ნახტომი აქვს უკვე figured რამ out თქვენთვის
და ასე რა ინფორმაციას გაქვთ ხელთ არსებობს.
და შემდეგ იქიდან მე რეკომენდაციას შესვლის ამ მარცხენა განყოფილებაში აქ,
რომელიც მიდის, ასევე ფაქტობრივად არ, ეს არის რეალურად მხოლოდ უფრო API პერსონალის ამაზე
>> TOMAS Reimers: API მითითება ბოლოში ჩვეულებრივ კარგი ადგილი წასვლა.
თქვენ ბიჭები ალბათ დაინახა ეს, როდესაც ჩვენ გავაკეთეთ Google Maps PSET.
მაგრამ მინიშნება ნამდვილად უბრალოდ გადის ყველა
ფუნქციები და პარამეტრები შესაძლებელია ობიექტი თქვენ.
>> Armaghan BEHLUM: ჰო.
მაგალითად, ეს არის ის, რაც მე ეძებდა ადრე.
როდესაც გვაქვს მხრივ, ჩვენ შეუძლია წავიდეს და გაერკვნენ
როგორ Leap ურჩევს ჩვენთვის მოძიების მხრივ.
როგორც ვთქვი ადრე, ჩვენ გვაქვს ხელში მასივი.
გაირკვეს, თუ ჩვენ გვაქვს ხელში და შემდეგ ცდილობენ და დაიბრუნოს ერთი მხრივ,
ურთიერთქმედება, რომ გზა.
ისე, რომ ის, რაც ჩვენ რეკომენდაცია თქვენ ბიჭები.
ჟესტები და პერსონალის ისევე.
ამ API დოკუმენტაცია აპირებს იყოს ფანტასტიკური ინსტრუმენტი თქვენ ბიჭები.
თუ თქვენ გაქვთ რაიმე სხვა რეკომენდაციები?
>> TOMAS Reimers: მე არ.
მე ვფიქრობ, რომ კარგი ახლა.
>> Armaghan BEHLUM: ჰო, მე ასე ვფიქრობ, ისევე.
მოგერიდებათ მოგვწეროთ და მიიღეთ დაუკავშირდა შესახებ Leap Motion
თუ თქვენ მქონე იქნებ რაიმე საკითხებზე ან გჭირდებათ რაიმე რეკომენდაციები.
და ჩვენ შეგვიძლია ცდილობენ და გაერკვნენ პერსონალი თქვენთან ერთად ბიჭები ასევე.
მადლობა.
>> TOMAS Reimers: Great.