[Powered by Google Translate] [Walkthrough - პრობლემა Set 4]
[Zamyla Chan - ჰარვარდის უნივერსიტეტი]
[ეს არის CS50. - CS50.TV]
ყველა უფლება. Hello, ყველას, და მივესალმები რომ Walkthrough 4.
>> დღეს ჩვენი pset არის სასამართლო ექსპერტიზის.
სასამართლო ექსპერტიზის მართლაც fun pset რომელიც მოიცავს საქმე Bitmap ფაილი
აღმოჩენა, რომლებმაც ჩაიდინეს დანაშაული.
მაშინ ჩვენ ვაპირებთ შემცირება გარკვეული Bitmap ფაილი
მაშინ ჩვენ ასევე ვაპირებთ გაუმკლავდეთ მართლაც fun ნაწილი მოუწოდა აღდგენა,
რომელშიც ჩვენ ძირითადად გადასცა მეხსიერების ბარათი
რომელშიც ვინმე შემთხვევით წაშლილი ყველა მათი ფაილი
და ჩვენ ვთხოვეთ ფეხზე იმ ფაილებს.
>> მაგრამ პირველი, სანამ ჩვენ შეღწევას pset, მე ნამდვილად უბრალოდ მინდა მივულოცო ყველას.
ჩვენ დაახლოებით შუაში ამ კურსის.
Quiz 0 არის ჩვენს უკან და ჩვენ დროს pset4, ისე არსებითად, ჩვენ შუა ნაწილამდე იყვნენ.
ჩვენ გრძელი გზა თუ ვიხსენებთ თქვენს psets, pset0 და pset1,
ასე მივულოცო თავის შესახებ, რომ,
და ჩვენ ვაპირებთ შეღწევას ზოგიერთი მართლაც fun stuff.
>> ასე რომ ჩვენი ყუთისთვის ამ pset, კიდევ ერთხელ, ნაცვლად გაშვებული sudo yum-y განახლება,
ჩვენ შეუძლია მხოლოდ აწარმოებს update50 თუ თქვენ საათზე ვერსია 17.3 და ზემოთ მოწყობილობის.
ასე რომ დარწმუნებული უნდა იყოს, რომ აწარმოებს update50 - ის ბევრი ადვილია, რამდენიმე ნაკლებად გმირები -
დარწმუნდით, რომ თქვენ დროს უახლესი ვერსია ელექტრო მოწყობილობების.
განსაკუთრებით მნიშვნელოვანია, რომ update50 როდესაც ჩვენ ვიწყებთ გამოყენებით CS50 ქვითარი.
ასე რომ დარწმუნდით რომ თქვენ რომ.
>> ყველა სექციები ამ pset,
ჩვენ ვაპირებთ იყოს საქმე ფაილის საშუალებებით და შედეგები, ფაილის I / O.
ჩვენ ვაპირებთ იყოს აპირებს მეტი ბევრი პროგრამების, რომ გაუმკლავდეთ კოლექტორები
მიუთითებს ფაილი და რამ, როგორიცაა, რომ
ამიტომ ჩვენ გვინდა დავრწმუნდეთ, რომ ჩვენ ნამდვილად ნაცნობი და კომფორტული
საქმე როგორ შეტანის და გამომავალი შევიდა ფაილი.
>> In განაწილების კოდი ამ pset არის ფაილი სახელად copy.c,
და ეს რაც ჩვენ ვაპირებთ იპოვოს იქნება ნამდვილად სასარგებლო ჩვენთვის
რადგან ჩვენ ვაპირებთ დასრულდება მდე რეალურად კოპირება copy.c ფაილი
და მხოლოდ შეცვლის მას ოდნავ შეძლებს მიაღწიოს პირველი 2 ნაწილების პრობლემა კომპლექტი.
>> და ასე შემდეგ, როგორც აღვნიშნე, სანამ, ჩვენ საქმე გვაქვს bitmaps ასევე JPEGs.
ასე ნამდვილად გაგება სტრუქტურა როგორ ეს ფაილები არ არიან ორგანიზებული,
როგორ შეგვიძლია ნამდვილად თარგმნოს 0S და 1s შევიდა structs
და რამ, რომ ჩვენ შეგვიძლია რეალურად გაიგოს და ინტერპრეტაცია და შეცვალონ,
რომ იქნება მართლაც მნიშვნელოვანი,
ასე მიდის JPEG და bitmap ფაილი და გაგება სტრუქტურა იმ.
>> Pset4, როგორც ყოველთვის, იწყება მონაკვეთზე კითხვები.
იმ იმუშავებს ფაილის I / O და მისაღებად თქვენ მიჩვეული რომ.
შემდეგ ნაწილი 1 არის Whodunit, რომელშიც თქვენ მოცემული Bitmap ფაილი
რომელიც გამოიყურება სახის მოსწონს წითელი წერტილების მთელი.
და მაშინ ძირითადად, რასაც ჩვენ ვაპირებთ გავაკეთოთ არის გადადგას ეს ფაილი და მხოლოდ შეცვალონ იგი ოდნავ
შევიდა ვერსია, რომ ჩვენ შეგვიძლია წაიკითხა.
არსებითად, ერთხელ ჩვენ დასრულდება, გვექნება იგივე ფაილი,
გარდა ჩვენ შევძლებთ, რომ ნახოთ დამალული გაგზავნა იმალება ყველა ის წითელი წერტილი.
მაშინ Resize არის პროგრამა, რომელიც, მოცემულ ფაილი
და შემდეგ სახელს ფაილი, რომ ეს მასალები და შემდეგ მიცემული ხმების ისევე,
რეალურად შეცვლის, რომ bitmap მიერ, რომ მთელი მნიშვნელობა.
მაშინ ბოლოს, ჩვენ გვაქვს აღდგენა pset.
ჩვენ მოცემულია მეხსიერების ბარათი და შემდეგ აქვს ფეხზე ყველა ფოტო
რომლებიც შემთხვევით წაშლილი,
მაგრამ, როგორც ჩვენ ვისწავლოთ, რეალურად არ წაიშლება და ამოღებულ ფაილი;
ჩვენ უბრალოდ სახის დაკარგა, სადაც ისინი იყვნენ ფაილი, მაგრამ ჩვენ ვაპირებთ ფეხზე რომ.
>> დიდი. ასე მიდის ფაილის I / O კონკრეტულად, ეს არის მთელი სია ფუნქციები რომ თქვენ გამოიყენებთ.
თქვენ უკვე ჩანს ცოტა საფუძვლები fopen, fread და fwrite,
მაგრამ ჩვენ ვაპირებთ შევხედოთ შემდგომი შევიდა ზოგიერთი ფაილის I / O ფუნქციები, როგორიცაა fputc,
რომელშიც თქვენ უბრალოდ დაწერეთ ერთი ხასიათი დროს,
to fseek, სადაც სახის გადაადგილება ფაილი თანამდებობა მაჩვენებელი ფორვარდები და უკან,
და შემდეგ რამდენიმე სხვა. მაგრამ ჩვენ წასვლას რომ მოგვიანებით დროს pset.
>> ასე რომ, პირველი, მხოლოდ შეღწევას ფაილის I / O სანამ წასვლას pset,
გახსნას ფაილი, მაგალითად, რას უნდა გავაკეთოთ ფაქტიურად მითითებული მომცეთ რომ ფაილი.
ამიტომ ჩვენ გვაქვს ი * მაჩვენებელი.
ამ შემთხვევაში, მე უწოდა წელს მაჩვენებელი იმიტომ, რომ იქნება ჩემი infile.
და მე ვაპირებ გამოვიყენო ფუნქცია fopen და შემდეგ სახელით ფაილი
და მაშინ რეჟიმი, რომელშიც მე ვაპირებ იყოს საქმე ფაილი.
ასე რომ არსებობს "რ" ამ შემთხვევაში წასაკითხად, "W" ში და შემდეგ "" ამისთვის appending.
მაგალითად, როდესაც თქვენ საქმე infile
და ყველა გსურთ არის წაკითხულად ბიტი და ბაიტი ინახება იქ,
მაშინ თქვენ ალბათ აპირებს გინდათ გამოიყენოთ "რ", როგორც თქვენი რეჟიმში.
როდესაც გსურთ რეალურად წერენ, სახის გააკეთოს ახალი ფაილი,
შემდეგ, რაც ჩვენ ვაპირებთ გავაკეთოთ არის ჩვენ ვაპირებთ გახსნა ახალი ფაილი
და გამოიყენოს "W" რეჟიმში წერა.
>> ასე რომ მაშინ, როდესაც თქვენ ფაქტიურად კითხულობს შევიდა ფაილები, სტრუქტურა ასეთია.
პირველ რიგში მოიცავს მომცეთ struct, რომელშიც იქნება ბაიტი, რომ თქვენ კითხულობს.
ასე რომ იქნება ბოლომდე ადგილმდებარეობის ბაიტი, რომ თქვენ კითხულობს.
თქვენ მაშინ აპირებს მიუთითებს ზომა, ისე, როგორც ძირითადად რამდენი ბაიტი
თქვენი პროგრამა უნდა წაიკითხონ, რათა ფაილი, ზომა ძირითადად ერთი ელემენტი,
და მაშინ თქვენ აპირებს დააკონკრეტა რამდენი ელემენტები გსურთ წაიკითხა.
და მაშინ საბოლოოდ, თქვენ უნდა იცოდეს, სადაც თქვენ კითხულობთ საწყისი,
ასე რომ იქნება თქვენი წელს მაჩვენებელი.
მე ფერი კოდირებული ეს იმიტომ fread ასევე ძალიან გავს fwrite,
გარდა თქვენ გვინდა დავრწმუნდეთ, რომ თქვენ იყენებთ სწორი მიზნით,
დარწმუნდით, რომ თქვენ რეალურად წერილობით ან კითხულობს მარჯვენა ფაილი.
>> ასე რომ მაშინ როგორც ადრე, თუ გვაქვს ზომა ელემენტს ისევე როგორც რიგი ელემენტები,
მაშინ ჩვენ შეუძლია გარშემო აქ ცოტა.
თქვათ, რომ DOG struct და ასე შემდეგ მინდა წაიკითხონ ორი ძაღლები დროს.
რა შეიძლება არ არის ამბობენ ზომის ერთ ელემენტს იქნება ზომა ერთი DOG
და მე ვაპირებ რეალურად წაიკითხა ორი მათგანი.
გარდა ამისა, რა შეიძლება გავაკეთოთ არის ამბობენ მე უბრალოდ აპირებს წაიკითხა ერთ ელემენტს
და რომ ერთ ელემენტს იქნება ზომის ორი ძაღლები.
ასე რომ ანალოგიური როგორ შეგიძლიათ სახის პიესის გარშემო ზომა და ნომერი
დამოკიდებულია რაც ინტუიციური თქვენ.
>> ყველა უფლება. ახლა მივიღებთ, რათა წერა ფაილი.
როცა გსურთ დაწეროთ ფაილი, პირველი არგუმენტი ფაქტიურად სადაც თქვენ კითხულობთ საწყისი.
ასე რომ ძირითადად მონაცემები, რომ თქვენ აპირებს დაწეროს იმ ფაილში,
რაც გარეთ მაჩვენებელი დასასრულს.
ასე რომ, როდესაც თქვენ საქმე pset, დარწმუნდით თქვენ არ მიიღებთ დაბნეული.
იქნებ აქვს განმარტებები თალიზში.
შეგიძლიათ დახევის განმარტებები წელს სახელმძღვანელო აკრეფით კაცი და შემდეგ fwrite, მაგალითად,
წელს ტერმინალი, ან შეგიძლიათ ეხება უკან ამ slide
და დარწმუნდით, რომ თქვენ იყენებთ სწორი ვარიანტი.
ასე რომ კიდევ ერთხელ, ამისთვის fwrite, როდესაც თქვენ გაქვთ ფაილი, რომელიც გსურთ წერენ შევიდა,
რომ იქნება ბოლო არგუმენტი და რომ იქნება მომცეთ რომ ფაილი.
ასე რომ მაშინ ასე ჩვენ გაუმკლავდეთ წერა ალბათ რამდენიმე ბაიტი დროს,
მაგრამ აცხადებენ გსურთ უბრალოდ დაწეროთ უბრალოდ ერთი ხასიათი.
როგორც ვნახავთ, მოგვიანებით ამ მაგალითად, bitmaps ჩვენ უნდა გამოვიყენოთ, რომ.
სწორედ მაშინ ჩვენ შეგვიძლია გამოვიყენოთ fputc, არსებითად მხოლოდ გამოსული ერთი ხასიათი დროს, Chr,
შევიდა ფაილის მაჩვენებელი და ეს ჩვენი გარეთ კურსორი იქ.
ასე რომ მაშინ როდესაც ჩვენ ვცდილობთ ან ჩაიწეროს, ფაილი,
ფაილი შენახვა ტრეკზე სადაც ჩვენ ვართ.
ასე რომ ერთგვარი კურსორს ფაილი თანამდებობა მაჩვენებელი.
და ა.შ. როდესაც ჩვენ წერენ ან წაიკითხა კვლავ ფაილი,
ფაილი რეალურად ახსოვს სადაც,
და ასე გრძელდება, საიდანაც კურსორი არის.
ეს შეიძლება იყოს მომგებიანი, როდესაც გსურთ, ვთქვათ, წაიკითხონ გარკვეული თანხა უნდა მოვიმოქმედოთ
და მერე წაიკითხონ შემდეგი ოდენობით,
მაგრამ ზოგჯერ ჩვენ დაგვჭირდება დაბრუნდეს ან რეალურად იწყება გარკვეული მინიშნება ღირებულება.
ასე რომ მაშინ fseek ფუნქცია, თუ რას აკეთებს არის საშუალებას გვაძლევს გადავიდეს კურსორი გარკვეული ფაილი
გარკვეული რაოდენობის ბაიტი.
და შემდეგ, რაც ჩვენ უნდა გავაკეთოთ არის დააკონკრეტა, სადაც მინიშნება ღირებულება.
ასე რომ არც ეს მოძრაობს წინ ან უკან საიდანაც კურსორი გაკეთებული არის,
ან ჩვენ შეუძლია მიუთითოს, რომ ეს უბრალოდ გადაადგილება დასაწყისიდან ფაილი
ან ფაილის ბოლოში.
და ასე რომ თქვენ შეგიძლიათ გადასცეთ ნეგატიური ან პოზიტიური ფასეულობები თანხა,
და რომელიც სახის გადაადგილეთ კურსორი ან ფორვარდები ან უკან.
>> სანამ შეღწევას სხვა psets, ნებისმიერი შეკითხვა ფაილის I / O?
Okay. როგორც მივიღებთ უფრო მაგალითები, მოგერიდებათ შემაჩერებს შეკითხვებზე.
>> ასე რომ Whodunit, თქვენ გადასცა Bitmap ფაილი მსგავსი ამ წითელი ერთი slide,
და ეს ასე გამოიყურება - bunch წითელი წერტილები - და თქვენ ნამდვილად არ ვიცი რა წერია.
თუ თქვენ squint, თქვენ შეიძლება ნახოს უმნიშვნელო bluish ფერი შიგნით ახლო.
არსებითად, ეს არის ის, სადაც ტექსტი ინახება.
მკვლელობა მოხდა, რაც მოხდა, და ჩვენ გვჭირდება, რათა გაირკვეს, ვინ ჩაიდინა ეს.
იმისათვის, რომ გავაკეთოთ, ჩვენ გვჭირდება სახის კონვერტაცია ამ გამოსახულების იკითხება ფორმატში.
თუ ბიჭები ოდესმე შეექმნა ამ, ზოგჯერ იქნებოდა პატარა კომპლექტები
სადაც თქვენ ექნება magnifying მინის ერთად წითელი ფილმი. ვინმე? Yeah.
ასე რომ თქვენ გადაეცემა მსგავსი რამ, თქვენ ექნება magnifying მინის
წითელი ფილმი მას, თქვენ მისთვის შეიძლება მეტი გამოსახულება,
და თქვენ იქნება ნახოს გაგზავნა იმალება მასში.
ჩვენ არ გვაქვს magnifying მინის წითელი ფილმი, ასე რომ ნაცვლად ჩვენ ვაპირებთ სახის შევქმნათ ჩვენი
ამ pset.
და ა.შ. მომხმარებლის აპირებს შეყვანის whodunit, მაშინ ნახავ,. Bmp,
ასე რომ infile, რომ წითელი dot გაგზავნა,
და მაშინ ისინი ამბობენ verdict.bmp იქნება ჩვენი outfile.
ამიტომ აპირებს შექმნას ახალი bitmap გამოსახულება მსგავსი ნახავ ერთი
გარდა იკითხება ფორმატში, სადაც ჩვენ ვხედავთ დამალული გაგზავნა.
>> ვინაიდან ჩვენ ვაპირებთ იყოს საქმე რედაქტირება და მანიპულირების bitmaps რაიმე სახის,
ჩვენ ვაპირებთ სახის Dive in შევიდა სტრუქტურის ამ Bitmap ფაილი.
წავედით ამ ცოტა ლექციების, მაგრამ მოდით წავიკითხოთ შევიდა მათ კიდევ რამდენიმე.
Bitmaps ძირითადად მხოლოდ მოწყობის ბაიტი
აქ ჩვენ მითითებული რომელიც bytes ნიშნავს რა.
ასე რომ აქ არის სახის მოსწონს რუკაზე bitmap გამოსახულება
რომ ეს იწყება რამდენიმე header ფაილი იწყება გარკვეული ინფორმაცია იქ.
თქვენ ხედავთ, რომ დაახლოებით ერთი ბაიტი ნომერი 14 ზომა მითითებულია of bitmap გამოსახულება,
და ეს გრძელდება.
მაგრამ მაშინ რა ჩვენ ნამდვილად დაინტერესებულია აქ იწყება გარშემო byte ნომერი 54.
ჩვენ გვყავს ამ RGB საწოლიანი.
რა, რომ აპირებს გააკეთოთ შეიცავდეს ფაქტობრივი პიქსელი, ფერი ღირებულებებს.
ყველაფერი ზემოთ რომ header არის გარკვეული ინფორმაცია
შესაბამისი ზომის გამოსახულება, სიგანე გამოსახულება, და სიმაღლე.
როდესაც ჩვენ წასვლას padding მოგვიანებით, ჩვენ დავინახავთ, თუ რატომ ზომა გამოსახულების
შეიძლება იყოს განსხვავებული, ვიდრე სიგანე ან სიმაღლე.
ასე შემდეგ წარმოადგენენ ამ - ამ bitmap გამოსახულებები sequences ბაიტების -
რაც ჩვენ შეიძლება არ არის ამბობენ okay, მე ვაპირებ გვახსოვდეს, რომ ინდექსი 14,
რომ სადაც ზომა არის, მაგალითად, არამედ ის, რასაც ჩვენ ვაპირებთ გავაკეთოთ იმისთვის, რომ ეს ადვილია
არის encapsulate ის struct.
ასე რომ, ჩვენ გვაქვს ორი structs გააკეთა ჩვენთვის, BITMAPFILEHEADER
და BITMAPINFOHEADER,
და ა.შ. როდესაც ვკითხულობთ, რომ ფაილი, სტანდარტულად ეს იქნება აპირებს იმისათვის,
და ასე, რათა ის ასევე აპირებს შეავსოს შევიდა ცვლადები როგორიცაა biWidth და biSize.
და მაშინ საბოლოოდ, ყველა pixel წარმოდგენილია სამი ბაიტი.
პირველი ის არის, თანხის ლურჯი in pixel, მეორე არის თანხის მწვანე,
და ბოლოს, თანხის წითელი, სადაც 0 არის არსებითად არ ლურჯი ან არა მწვანე ან არა წითელი
და მაშინ FF არის მაქსიმალური მნიშვნელობა.
ეს არის თექვსმეტობითი ღირებულებებს.
ასე რომ თუ გვაქვს ff0000, მაშინ ეს შეესაბამება მაქსიმალური ლურჯი
და მაშინ არ მწვანე და არ წითელი, ასე შემდეგ, რომ მოგვცეს ლურჯი pixel.
თუ ჩვენ გვაქვს ff ს მთელს ფორუმში, მაშინ ეს იმას ნიშნავს, რომ ჩვენ გვაქვს თეთრი pixel.
ეს არის სახის საპირისპიროდ, როგორც წესი, როდესაც ჩვენ ვამბობთ, RGB. სინამდვილეში აპირებს BGR.
>> ასე რომ, თუ ჩვენ რეალურად შესასწავლად მაგალითი bitmap გამოსახულება - ნება მომეცით გაიყვანოს ერთი აქ.
ეს პატარა პატარა.
მე zooming in, და ვხედავთ მას pixelated. როგორც ჩანს ბლოკები ფერი.
თქვენ გაქვთ თეთრი ბლოკები და შემდეგ წითელი ბლოკები.
თუ თქვენ ითამაშოს Microsoft Paint, მაგალითად, თქვენ შესაძლოა რაღაც მსგავსი
მიერ ძირითადად მხოლოდ ხატვის გარკვეული სკვერების კონკრეტული მიზნით.
ასეა, მაშინ რა ამ ითარგმნება ამ bitmap ასეთია.
აქ პირველი თეთრი პიქსელი, რომ ყველა 6 არიან ვ, შემდეგ კი გვაქვს წითელი პიქსელი,
მიერ მითითებულ 0000ff.
და ა.შ. თანმიმდევრობა bytes რომ ჩვენ გვაქვს მიუთითებს როგორ bitmap გამოსახულება აპირებს გამოიყურებოდეს.
მერე რა მე ვაკეთებ აქ არის მხოლოდ წერილობითი ყველა იმ bytes და შემდეგ ფერადი წითელ
ასე რომ თქვენ შეგიძლიათ სახის ვხედავთ, თუ squint ცოტა, როგორ ასეთი სახის მიუთითებს smiley face.
>> ისე, რომ Bitmap images მუშაობა მე გვჯერა ეს ძირითადად, როგორც ბადე.
და ასე იყოს, ყოველ გრაფაში ქსელის უნდა იყოს ჯერადი 4 ბაიტი.
თუ დავაკვირდებით bitmap გამოსახულება, თქვენ შევსების ყველა ღირებულება.
მაგალითად, თქვენ ალბათ წითელი აქ, მწვანე აქ, ლურჯი აქ,
მაგრამ თქვენ უნდა დავრწმუნდეთ, რომ გამოსახულება ივსება ერთად მრავალი ოთხი ბაიტი.
ასე რომ, თუ მინდა ჩემი ფოტო არ იყოს სამ ფართო, მაშინ მე უნდა დააყენოს ცარიელი ღირებულება
ამ ბოლო ერთი რათა ის მრავალჯერადი ოთხი.
ასეა, მაშინ მე დაუმატებს რაც ჩვენ მოუწოდებდა padding.
მე უბრალოდ აპირებს მიუთითებს, რომ იქ x.
ახლა ამბობენ, ჩვენ გვინდა, რომ გამოსახულება არის 7 პიქსელი ხანგრძლივი, მაგალითად.
ჩვენ გვყავს 1, 2, 3, 4, 5, 6, 7,
და ყველა რომ ივსება ფერადი.
ისე, რომ Bitmap images მუშაობა არის ის, რომ ჩვენ გვჭირდება მე -8.
ამ დროისათვის ჩვენ გვყავს 1, 2, 3, 4, 5, 6, 7.
ჩვენ გვჭირდება 8 ფართების bitmap გამოსახულება იკითხება სწორად.
ასე შემდეგ, რაც ჩვენ უნდა გავაკეთოთ არის ის რომ დაამატოთ რაღაც ცოტა padding
დავრწმუნდეთ, რომ ყველა widths are უნიფორმა
და რომ ყველა widths are ჯერადი 4.
და მე ადრე მითითებული, დასატენი როგორც x ან squiggly ხაზი,
მაგრამ ფაქტობრივი Bitmap images padding მითითებულია მიერ თექვსმეტობითი 0.
ასე რომ იქნება ერთი ხასიათი, 0.
რა შეიძლება დადგეს მოსახერხებელი არის xxd ბრძანება.
რა ეს იმას ფაქტიურად გიჩვენებთ, ისევე როგორც მსგავსი რა მე ადრე ერთად smiley
როცა რეალურად დაბეჭდილი რა თითოეული ფერი იქნებოდა ამისთვის pixel
და შემდეგ ფერი კოდირებული, როდესაც თქვენ აწარმოებს xxd შემდეგი ბრძანებები,
მაშინ რეალურად ბეჭდვა რა ფერის არის მათთვის, pixels.
რა უნდა გააკეთოთ მეტი აქ მიუთითებს, როგორიც-s 54
ამბობს, რომ მე ვაპირებ დაიწყება 54TH byte
რადგან მანამდე, გახსოვთ თუ გადავხედავთ თავში რუკაზე bitmaps,
რომ ყველა ჰედერი ინფორმაცია და რამ, როგორიცაა, რომ.
მაგრამ რაც ჩვენ ნამდვილად აინტერესებს არის ფაქტობრივი პიქსელი, რომ მიუთითოს ფერი.
ამიტომ დანამატის ამ დროშას,-s 54, მაშინ ჩვენ ნახოს ფერი ღირებულებებს.
და არ ინერვიულოთ რთული დროშებით და რამ, როგორიცაა, რომ.
პრობლემის კომპლექტი Spec, თქვენ მიმართულებების შესახებ თუ როგორ გამოიყენოთ xxd ცარიელია pixels.
ასე რომ, თუ ხედავთ აქ, ეს ერთგვარი ჰგავს მწვანე ყუთი, ამ პატარა რამ.
მე ფერი კოდირებული 00ff00 როგორც ძირითადად ამბობდა არ ლურჯი, ბევრი მწვანე და წითელი არ.
ასე რომ შეესაბამება მწვანე.
როგორც ხედავთ, ჩვენ ვხედავთ მწვანე მართკუთხედი.
ეს მწვანე ოთხკუთხედი მხოლოდ 3 პიქსელი ფართო, ასე შემდეგ, რაც ჩვენ უნდა გავაკეთოთ
დარწმუნდით, რომ სურათი არის ჯერადი 4 ფართო არის დაამატოთ დამატებით padding.
და ასე შემდეგ ასე ხედავთ ამ 0S აქ.
ეს რეალურად იყოს შედეგად თქვენი Resize pset,
არსებითად აღების მცირე bitmap და შემდეგ გაფართოების იგი 4.
და მერე რა ჩვენ ვხედავთ ის არის, რომ რეალურად ეს სურათი არის 12 პიქსელი ფართო, მაგრამ 12 არის ჯერადი 4,
და ამიტომ ჩვენ რეალურად ვერ ვხედავ 0S დასასრულს, რადგან ჩვენ არ გვჭირდება რომ დაამატოთ ნებისმიერი
რადგანაც ეს მთლიანად padded. ეს არ აქვს მეტი ოთახი.
>> Okay. რაიმე კითხვა padding?
Okay. ზემოთ.
>> როგორც აღვნიშნე ადრე, bitmaps მხოლოდ თანმიმდევრობა bytes.
და ა.შ. რაც გვაქვს არის ნაცვლად სჭირდება შენარჩუნება ტრეკზე ზუსტად რომელიც ხმების byte
შეესაბამება კონკრეტული ელემენტის, ჩვენ რეალურად შევქმენით struct წარმოადგინოს, რომ.
ასე რომ, რაც გვაქვს არის RGBTRIPLE struct.
როდესაც თქვენ გაქვთ ინსტანციის RGB triple,
რადგან ეს არის ტიპის განსაზღვრა struct, მაშინ შეგიძლიათ rgbtBlue ცვლადი,
ასეთივე მწვანე და წითელი ცვლადები, რომელიც მიუთითებს, თუ რამდენად ცისფერი, მწვანე, წითელი და,
შესაბამისად, თქვენ გაქვთ.
>> ასე რომ, თუ ჩვენ გვაქვს ლურჯი ცვლადი დაყენებულია 0, მწვანე კომპლექტი ff,
რაც მაქსიმალური მნიშვნელობა შეგიძლიათ, შემდეგ კი წითელი ცვლადი მითითებული 0,
მაშინ რა ფერი იქნებოდა ამ კონკრეტულ RGB სამმაგი წარმოადგენს? >> [სტუდენტი] მწვანე.
მწვანე. სწორედ.
ეს იქნება სასარგებლო იცოდეთ, რომ როდესაც თქვენ გაქვთ ინსტანციის RGB triple,
შეგიძლიათ პრაქტიკულად შედიხართ თანხის ფერი - ლურჯი, მწვანე, წითელი და - ცალკე.
>> არის, რომ ჩვენ ვისაუბრეთ სტრუქტურას, რომ, მოდით, შევხედოთ BMP ფაილი.
ესენია structs გააკეთა თქვენთვის.
აქ BITMAPFILEHEADER struct.
აღსანიშნავია ზომა.
მოგვიანებით, ჩვენ გვაქვს ინფორმაცია სათაურის, რომელსაც აქვს რამდენიმე რამ, რომ საინტერესოა ჩვენთვის,
კერძოდ ზომა, სიგანე და სიმაღლე.
როგორც ჩვენ წასვლას შემდეგ, როდესაც წაიკითხავთ, რათა ფაილი,
ეს ავტომატურად ნათქვამია, რადგან ჩვენ მითითებული რათა იყოს იგივე.
ამიტომ biSize შეიცავს უფლება ბაიტი, რომელიც შეესაბამება ფაქტობრივი ზომის გამოსახულება.
და შემდეგ აქ, ბოლოს, როგორც ჩვენ ვისაუბრეთ, ჩვენ გვაქვს RGBTRIPLE typedef struct.
ჩვენ გვყავს rgbtBlue, მწვანე, წითელი და ასოცირდება იგი.
>> დიდი. Okay.
ახლა, როდესაც ჩვენ გვესმის bitmaps ცოტა, გვესმოდეს, რომ ჩვენ გვაქვს ფაილის header
და ინფორმაციის header ასოცირდება და მერე ამის შემდეგ, ჩვენ გვაქვს საინტერესო პერსონალის
საქართველოს ფერები, და იმ ფერის წარმოდგენილია RGBTRIPLE structs,
და მათ, თავის მხრივ, აქვს სამი ღირებულებების ასოცირებული ცისფერი, მწვანე, და წითელი.
>> ასე რომ ახლა შეგვიძლია სახის ვიფიქროთ აღდგენა bit.
უკაცრავად. იფიქრეთ Whodunit.
როცა ჩვენ გვაქვს ჩვენი ნახავ ფაილი, მაშინ ის, რაც ჩვენ გვსურს რომ არის წაიკითხონ მას pixel მიერ pixel
და მერე რაღაცნაირად შეცვლის იმ პიქსელი ისე, რომ ჩვენ შეგვიძლია დაბეჭდავს იგი იკითხება ფორმატში.
და ასე დაბეჭდავს, ჩვენ ვაპირებთ დავწეროთ pixel მიერ pixel შევიდა verdict.bmp ფაილი.
სწორედ ამგვარი ბევრი უნდა გააკეთოს. ჩვენ ვაცნობიერებთ, რომ.
ამიტომ, რაც ჩვენ გავაკეთეთ არის ჩვენ ფაქტობრივად გათვალისწინებული თქვენ copy.c.
რა copy.c არ არის მხოლოდ ხდის ზუსტი ასლი მოცემული Bitmap ფაილი და შემდეგ შედეგები იგი.
ასე რომ, ეს უკვე ხსნის ფაილი თქვენთვის, ნათქვამია in pixel მიერ pixel,
და შემდეგ წერს იგი შევიდა გამომავალი ფაილი.
>> მოდით შევხედოთ, რომ.
ეს უზრუნველყოფა სათანადო გამოყენება,
მიღების filenames აქ.
რა ეს იმას არის ის ისეთ ფაილისთვის იქნება რა ჩვენ გავიდა წელს infile აქ,
რომელიც არის ჩვენი მეორე ბრძანება ხაზი არგუმენტი.
ამოწმებს რომ დავრწმუნდეთ, რომ ჩვენ შეგვიძლია გავხსნათ ფაილი.
ამოწმებს რომ დავრწმუნდეთ შეიძლება გავაკეთოთ ახალი outfile აქ.
აბა რა ეს იმას აქ, უბრალოდ ძირითადად იწყება კითხულობს, რათა Bitmap ფაილი დასაწყისია.
დასაწყისში, როგორც ვიცით, შეიცავს BITMAPFILEHEADER,
და ასე იმ sequences ბიტების იქნება პირდაპირ შეავსოთ BITMAPFILEHEADER.
რა გვაქვს აქ ამბობს, რომ BITMAPFILEHEADER BF -
რომ ჩვენი ახალი ცვლადი ტიპის BITMAPFILEHEADER -
ჩვენ ვაპირებთ დააყენა შიგნით BF რაც ჩვენ წაკითხვის წელს მაჩვენებელი, რომელიც ჩვენი infile.
რამდენად ვკითხულობთ?
ვკითხულობთ, თუ რამდენი ბაიტი გვჭირდება შეიცავდეს მთელი BITMAPFILEHEADER.
ანალოგიურად, რომ ის, რასაც ჩვენ გავაკეთებთ ამისთვის ინფორმაცია header.
ამიტომ ჩვენ ვაგრძელებთ გასწვრივ ჩვენი ფაილის infile,
და ჩვენ კითხულობს იმ ბიტი და ბაიტი და ჩვენ ჩართვის მათ პირდაპირ
შევიდა ამ ინსტანციის ცვლადები, რომ ჩვენ მიღების.
აქ ჩვენ უბრალოდ მიღების დარწმუნებული ვარ, რომ bitmap არის Bitmap.
>> ახლა ჩვენ გვაქვს outfile, არა?
ასე რომ, როგორც იგი დგას, როდესაც ჩვენ შექმნა, ეს არსებითად ცარიელი.
ამიტომ, ჩვენ უნდა შევქმნათ ძირითადად ახალი bitmap ნულიდან.
რას ვაკეთებთ არის ჩვენ უნდა დავრწმუნდეთ, რომ ჩვენ ასლი ფაილი header
და ინფორმაციის header ისევე infile აქვს.
რას ვაკეთებთ ჩვენ წერენ - და გვახსოვდეს, რომ BF არის ცვლადი
ტიპის BITMAPFILEHEADER, ამიტომ, თუ რას ვაკეთებთ ჩვენ მხოლოდ გამოიყენოთ, რომ კონტენტი
დაწერა შევიდა outfile.
აქ, გახსოვთ ჩვენ ვისაუბრეთ padding,
როგორ მნიშვნელოვანია დავრწმუნდეთ, რომ თანხის პიქსელი, რომ ჩვენ გვაქვს არის ჯერადი 4.
ეს არის საკმაოდ სასარგებლო formula გამოთვლა რამდენად padding გაქვთ
მოცემული სიგანე თქვენი ფაილი.
მინდა ბიჭები უნდა გვახსოვდეს, რომ copy.c გვაქვს formula გაანგარიშების padding.
Okay? ასე ყველას გვახსოვდეს, რომ. დიდი.
ასეა, მაშინ რა copy.c აკეთებს შემდეგი არის ის iterates მეტი ყველა scanlines.
იგი გადის რიგები და შემდეგ ინახავს ყველა triple, რომ ეს ნათქვამია
და შემდეგ წერს იგი outfile.
ასე შემდეგ აქ ჩვენ კითხულობს მხოლოდ ერთი RGB სამმაგი დროს
და შემდეგ აყენებს, რომ იგივე სამმაგი შევიდა outfile.
ადვილი ნაწილი არის ის, რომ padding არ არის RGB triple,
და ა.შ. ჩვენ არ შეგვიძლია უბრალოდ წაიკითხა, რომ padding თანხის RGB საწოლიანი.
რა უნდა გავაკეთოთ, ფაქტობრივად მხოლოდ გადავიდეს ჩვენი ფაილი თანამდებობა მაჩვენებელი გადატანა ჩვენი კურსორს
to სახის გამოტოვოთ ყველა padding ასე რომ ჩვენ მომდევნო მწკრივში.
და მერე რა ეს იმას არის ასლი გიჩვენებთ თუ როგორ დაგვჭირდება დაამატოთ padding.
ამიტომ ჩვენ გამოითვლება რამდენად padding გვჭირდება,
ასე რომ იმას ნიშნავს, რომ ჩვენ გვჭირდება padding ხმების 0S.
რა ეს იმას არის ამისთვის loop რომ აყენებს padding ხმების 0S ჩვენს outfile.
და მაშინ საბოლოოდ, თქვენ დახურვა ორივე ფაილი. თქვენ დახურვა infile ასევე outfile.
>> ასე რომ, თუ როგორ copy.c სამუშაოები,
და ეს იქნება საკმაოდ სასარგებლო.
ნაცვლად მხოლოდ რეალურად პირდაპირ კოპირება და pasting ეს
ან უბრალოდ ეძებს მას და აკრეფით რაც გაგიხარდებათ,
თქვენ ალბათ უბრალოდ შეასრულოს ამ ბრძანების ტერმინალში,
CP copy.c whodunit.c, რომელიც შექმნის ახალ ფაილს, whodunit.c,
რომელიც შეიცავს ზუსტად იგივე კონტენტი, როგორც ასლი აკეთებს.
ასეა, მაშინ რა შეგვიძლია გავაკეთოთ არის გამოვიყენოთ, რომ როგორც ჩარჩოებს, რომელთაც აშენება და შეცვალონ
ჩვენი whodunit ფაილი.
>> ეს არის ჩვენი to-dos გავაკეთოთ ამისთვის Whodunit, მაგრამ რას აკეთებს copy.c
რეალურად ზრუნავს მათი უმრავლესობა ჩვენთვის.
ამიტომ ყველა უნდა გავაკეთოთ შემდეგი შეცვალოთ პიქსელი როგორც საჭიროა
რეალურად მიიღოს ფაილი იკითხება.
გახსოვდეთ, რომ მოცემული pixel triple, ისე მოცემული ცვლადი ტიპის RGBTRIPLE,
თქვენ შეგიძლიათ თქვათ ცისფერი, მწვანე, წითელი და ღირებულებებს.
რომ აპირებს მოდის მოსახერხებელი რადგან თუ შეგიძლიათ თქვათ მათ,
რაც იმას ნიშნავს, რომ თქვენ შეგიძლიათ შეამოწმოთ მათ,
და ეს ნიშნავს, რომ თქვენ შეგიძლიათ ასევე მათი შეცვლა.
>> ასე რომ, როდესაც ჩვენ დაბრუნდა ჩვენი წითელი magnifying მინის მაგალითად,
ძირითადად, რომელიც მოქმედებს როგორც ერთგვარი ფილტრის ჩვენთვის.
ამიტომ, რაც ჩვენ გვსურს რომ არის ჩვენ გვინდა, რათა გავფილტროთ ყველა საწოლიანი, რომლებიც უერთდებიან
არსებობს რამოდენიმე განსხვავებული გზა ამის გაკეთება.
ძირითადად, თქვენ შეგიძლიათ რასაც ტიპის ფილტრი გსურთ.
იქნებ თქვენ გსურთ შეცვალოთ ყველა წითელი პიქსელი
ან იქნებ თქვენ გსურთ შეცვალოთ სხვადასხვა ფერი pixel სხვადასხვა ფერი.
სწორედ თქვენზეა.
გახსოვდეთ, რომ თქვენ შეგიძლიათ შეამოწმოთ თუ რა ფერი პიქსელზე
და მაშინ ასევე იცვლება, როგორც თქვენ გადის.
>> Okay. ასე რომ Whodunit.
ერთხელ თქვენ აწარმოებს Whodunit, თქვენ იცით ვინ culprit დანაშაულის იყო.
>> ახლა ჩვენ ვაპირებთ წასვლა ზომის შეცვლა.
ჩვენ ვაპირებთ კვლავ საქმე bitmaps.
ის, რასაც ჩვენ ვაპირებთ გავაკეთოთ არის ჩვენ ვაპირებთ აქვს შეყვანის bitmap
და მაშინ ჩვენ ვაპირებთ გაივლის მთელ რიგ და შემდეგ მიიღოს outfile bitmap
აქ რომ ძირითადად ჩვენი infile მასშტაბური მიერ n.
Say ჩემი ფაილი იყო მხოლოდ ერთი დიდი pixel.
თუ ჩემი n იყო 3, სკალირების მიერ 3, მაშინ მინდა გავიმეორო, რომ pixel N რამდენჯერმე,
ასე 3 ჯერ, ხოლო შემდეგ ასევე მასშტაბის მისი დანგრევა 3 ჯერ ისევე.
ასე რომ ხედავთ მე სკალირების ეს ვერტიკალურად ასევე ჰორიზონტალურად.
>> და მერე აქ მაგალითად.
თუ თქვენ გაქვთ N = 2, ხედავთ, რომ პირველი ლურჯი pixel იქ გაიმეორა ორჯერ
ჰორიზონტალურად ასევე ორჯერ ვერტიკალურად.
და მაშინ ეს გრძელდება, და ასე რომ თქვენ არ პირდაპირი სკალირების თქვენი თავდაპირველი სურათის ორი.
>> ასე რომ თუ ჩვენ დეტალურად pseudocode ამ, ჩვენ გვინდა გავხსნათ ფაილი.
და მაშინ იცოდა, რომ თუ ჩვენ დავბრუნდებით აქ,
ჩვენ ვხედავთ, რომ სიგანე outfile იქნება განსხვავებული სიგანე infile.
რას ნიშნავს ეს?
ეს იმას ნიშნავს, რომ ჩვენი header ინფორმაციის შეიცვლება.
და მერე რა ჩვენ გვსურს რომ არის განაახლოს header ინფორმაცია,
იცის, რომ როდესაც ვკითხულობთ ფაილები თუ თქვენ ფუნქციონირებს copy.c ფარგლებში,
ჩვენ უკვე გვაქვს ცვლადი მიანიშნებს, თუ რა ზომის არის და რამ, როგორიცაა, რომ.
ასე რომ ერთხელ თქვენ, რომ, რა დაგვჭირდება უნდა შეცვალოთ იმ კონკრეტულ ცვლადები.
გახსოვდეთ, თუ თქვენ გაქვთ struct, როგორ თქვენ შედიხართ ცვლადები შიგნით რომ.
თქვენ გამოიყენოთ dot ოპერატორი, არა?
ასეა, მაშინ გამოყენებით, რომ თქვენ იცით, რომ თქვენ უნდა შეცვალოს header ინფორმაცია.
ასე რომ აქ უბრალოდ სიაში ფაქტობრივი ელემენტები, რომლებიც უნდა შეცვლის თქვენს ფაილს.
ფაილის ზომა იქნება შეცვლა, გამოსახულება, ასევე სიგანე და სიმაღლე.
ასეა, მაშინ ბრუნდება რუკაზე bitmaps,
შევხედოთ თუ არა ეს ფაილი სათაური, ან ინფორმაცია header რომ შეიცავს, რომ ინფორმაცია
და შემდეგ შეცვალოს როგორც საჭიროა.
ერთხელ, ვთქვათ CP copy.c resize.c.
ეს იმას ნიშნავს, რომ ახლა resize.c შეიცავს ყველაფერს რომ შეიცავდა შიგნით ასლი
რადგან ასლი გვაძლევს გზა კითხულობს წელს ყოველი scanline pixel მიერ pixel.
გარდა ახლა, ნაცვლად მხოლოდ იცვლება ღირებულებები ისე, როგორც წელს Whodunit,
რაც ჩვენ გვსურს რომ არის გვინდა დაწერა რამდენიმე პიქსელი
რადგან ჩვენი n მეტია 1.
>> შემდეგ, რაც ჩვენ გვსურს რომ არის ჩვენ გვინდა მონაკვეთი მას ჰორიზონტალურად მიერ N,
ასევე მონაკვეთი მას ვერტიკალურად მიერ n.
როგორ შეიძლება გავაკეთოთ ეს?
Say თქვენი N 2 და თქვენ ეს მოცემული infile.
კურსორი აპირებს იწყება პირველი,
და რა გსურთ, თუ N არის 2, გსურთ დაბეჭდე 2 იმ.
ასე, რომ თქვენ დაბეჭდე 2 იმ.
მაშინ კურსორი აპირებს გადავა შემდეგი pixel, რომელიც წითელი ერთი,
და ის აპირებს ამობეჭდოთ 2 იმ წითელი პირობა, appending ის გადატანა რასაც ის გაკეთდეს ადრე.
მაშინ კურსორი გადავა შემდეგი pixel და ჩაერთონ 2 იმ.
თუ გადავხედავთ თავში copy.c ფარგლებში, რა ეს იმას უფლება აქ
იგი ქმნის ახალ ინსტანციის RGB triple, ახალი ცვლადში triple.
და აქ, როდესაც ეს ნათქვამია მივანიჭო, ნათქვამია მოხსენებაში საწყისი infile 1 RGBTRIPLE
და ინახავს მას შიგნით რომ სამმაგი ცვლადი.
ასეა, მაშინ თქვენ ნამდვილად აქვს ცვლადი წარმოადგენს კონკრეტულ pixel.
მაშინ როდესაც ვწერთ, რა შეიძლება ჩვენ უნდა encase fwrite განაცხადი შევიდა ამისთვის loop
რომ წერს იგი თქვენი outfile როგორც მრავალჯერ საჭირო.
სწორედ მარტივი საკმარისი.
უბრალოდ ძირითადად ვიმეორებ წერის პროცესში N რაოდენობის ჯერ მასშტაბის მას ჰორიზონტალურად.
>> მაგრამ შემდეგ ჩვენ უნდა გვახსოვდეს, რომ ჩვენი padding აპირებს შეცვალოს.
მანამდე, ვთქვათ, რომ ჩვენ გვქონდა რაღაც სიგრძე 3.
მაშინ ჩვენ უბრალოდ დაამატე რამდენად padding? კიდევ ერთი, რათა ის ჯერადი 4.
მაგრამ ამბობენ ჩვენ სკალირების ამ კონკრეტულ გამოსახულება მიერ N = 2.
ასეა, მაშინ რამდენი ლურჯი პიქსელი რომ ჩვენ გვაქვს დასასრულს? გვექნებოდა 6.
1, 2, 3, 4, 5, 6. ყველა უფლება.
6 არ არის ჯერადი 4. რა არის უახლოეს ჯერადი 4? რომ იქნება 8.
ასე რომ ჩვენ რეალურად აპირებს 2 გმირები padding არსებობს.
>> ვინმეს გახსოვთ თუ გვაქვს formula გამოთვლა padding
და სადაც ეს შეიძლება?
[Inaudible სტუდენტი საპასუხოდ] >> Yeah, copy.c. მარჯვენა.
არსებობს ფორმულა წელს copy.c გამოთვლა რამდენად padding გაქვთ
მოცემულ კონკრეტულ სიგანე bitmap გამოსახულება.
ასე რომ მაშინ ეს იქნება სასარგებლო, როდესაც თქვენ გჭირდებათ რომ დაამატოთ გარკვეული თანხის padding
რეალურად გაერკვნენ, თუ რამდენად padding თქვენ უნდა დაამატოთ.
მაგრამ ერთი შენიშვნა, თუმცა, ის არის, რომ თქვენ გვინდა დავრწმუნდეთ, რომ თქვენ იყენებთ სწორი ზომა.
უბრალოდ ფრთხილად, რადგან თქვენ ძირითადად იქნება საქმე ორი Bitmap images.
თქვენ გვინდა დავრწმუნდეთ, რომ თქვენ იყენებთ სწორი ვარიანტი.
როდესაც თქვენ გაანგარიშების padding ამისთვის outfile, რომლის გამოყენებაც გსურთ სიგანე outfile
და არა სიგანე წინა.
>> დიდი. ამ ტიპის ზრუნავს გაჭიმვა მთელი bitmap გამოსახულება ჰორიზონტალურად.
მაგრამ რაც ჩვენ გვსურს რომ რეალურად ეს მონაკვეთი ვერტიკალურად ასევე.
ეს იქნება ცოტა trickier რადგან, როდესაც ჩვენ დასრულდა გადაწერა row
და წერა ამ რიგის, ჩვენი კურსორი იქნება ბოლოში.
ასე რომ, თუ ჩვენ წაიკითხა ერთხელ, მაშინ ის უბრალოდ აპირებს წაიკითხონ მომდევნო ხაზი.
ამიტომ, რაც ჩვენ გვსურს რომ არის სახის გამოძებნოს გზა კოპირება იმ რიგების ერთხელ
ან უბრალოდ სახის აღება, რომ ზედიზედ და მერე გადაწერა ხელახლა.
როგორც I ტიპის გააკეთა მინიშნება, არსებობს რამდენიმე განსხვავებული გზა ამის გაკეთება.
რა შეგიძლიათ გააკეთოთ როგორც თქვენ გადის და კითხულობს მეშვეობით კერძოდ scanline
და შეცვლის, როგორც აუცილებელი, მაშინ სახის შენახვის ყველა იმ პიქსელი მასივი.
მაშინ მოგვიანებით თქვენ იცით, რომ თქვენ უნდა ამობეჭდოთ, რომ მასივი ერთხელ,
და ასე რომ თქვენ შეგიძლიათ მხოლოდ გამოიყენოთ, რომ მასივი გაგვაჩნია.
კიდევ ერთი გზა ამის გაკეთება არის შესაძლებელი გახდება კოპირება ქვემოთ ერთ მწკრივში,
მესმის, რომ თქვენ უნდა კოპირება რომ ერთხელ, ასე რომ რეალურად ამოძრავეთ კურსორი,
და რომ იქნება გამოყენებით მეთოდი fseek.
თქვენ შეიძლება გადავიდეს კურსორი ყველა გზა უკან და შემდეგ გაიმეოროს ასლი პროცესი ისევ.
>> ასე რომ, თუ ჩვენი სკალირების რიცხვი n, მაშინ რამდენჯერ იქნებოდა ჩვენ უნდა დაბრუნდეს
და გადმოეცით ხაზი? >> [სტუდენტი] n - 1. >> Yeah, სრულყოფილი. N - 1.
ჩვენ გავაკეთეთ ეს ერთხელ უკვე, ასე რომ მაშინ ჩვენ გვინდა გავიმეოროთ, რომ დაუბრუნდეს პროცესი
N - 1 ოდენობა ჯერ.
Okay. ასე რომ თქვენ გაქვთ თქვენი Resize ფუნქციას.
>> ახლა ჩვენ შეგვიძლია მოხვედრა ნამდვილად fun ნაწილი, ჩემი საყვარელი pset, რაც აღდგენა.
ნაცვლად bitmaps, ამ დროს ჩვენ საქმე გვაქვს JPEGs.
ჩვენ რეალურად არ აძლევენ ფაილი მარტო JPEGs,
ჩვენ მოცემული ძირითადად ნედლეულის მეხსიერების ბარათის ფორმატი.
და ამიტომ ეს შეიცავს ცოტა ინფორმაცია და ნაგვის ღირებულებების დასაწყისში,
და მაშინ იწყება და მას აქვს bunch of JPEG ფაილები.
თუმცა, ჩვენ გადავეცით განყოფილებიდან სადაც ჩვენ წაშლილი ფოტოსურათი;
არსებითად, ჩვენ დავიწყებას სადაც ფოტოები ფარგლებში მდებარე ბარათი.
ასე რომ მაშინ ჩვენი ამოცანა აღდგენა არის გავლა ამ ბარათის ფორმატი
და იპოვოს ის სურათები კვლავ.
>> საბედნიეროდ, სტრუქტურა JPEG ფაილები და განყოფილებიდან ფაილი bit გამოსადეგი.
ეს ნამდვილად იქნებოდა ცოტა trickier თუ იგი არ იყო ამ კონკრეტულ ფორმატში.
ყველა JPEG ფაილის რეალურად იწყება ორი შესაძლო sequences, ზემოთ ჩამოთვლილი.
ძირითადად, როდესაც თქვენ გაქვთ ახალი JPEG ფაილის,
იგი იწყება ან თანმიმდევრობა ffd8 ffe0 ან სხვა ერთი, ffd8 ffe1.
კიდევ ერთი სასარგებლო რამ ვიცი ის არის, რომ JPEGs ინახება contiguously.
ასე რომ როდესაც ერთი JPEG ფაილის დამთავრდა, მეორე იწყება.
ასე რომ არ არსებობს რაიმე სახის შორის ღირებულებები არსებობს.
ერთხელ თქვენ მოხვდა დაწყების JPEG, თუ თქვენ უკვე კითხულობს JPEG,
თქვენ იცით, რომ თქვენ მოხვდა ბოლოს წინა ერთი და დაწყების შემდეგ.
>> To სახის ვიზუალიზაციისთვის ეს, მე მივიღე სქემატური.
კიდევ ერთი რამ შესახებ JPEGs არის, რომ ჩვენ შეგვიძლია წაიკითხა მათ sequences of 512 ბაიტი დროს,
ანალოგიურად ერთად დასაწყისში ბარათი.
ჩვენ არ უნდა მოხდეს შემოწმების თითოეული byte იმიტომ, რომ suck.
ასე რომ ნაცვლად, რა შეგვიძლია რეალურად მხოლოდ იკითხება 512 ბაიტი დროს
და მაშინ, ნაცვლად შემოწმების შორის იმ იმ პატარა პატარა ნაჭერი,
ჩვენ შეგვიძლია მხოლოდ შეამოწმოთ დასაწყისში 512 ბაიტი.
არსებითად, ამ სურათში, რა ხედავთ არის დასაწყისში ბარათი,
თქვენ გაქვთ ღირებულებები, რომლებიც არ არიან ნამდვილად შესაბამისი ფაქტობრივი JPEGs თავს.
მაგრამ შემდეგ რა არის ვარსკვლავი მიუთითოს ერთი ორი დაწყებული sequences for JPEG.
ასე რომ როდესაც ხედავთ ვარსკვლავი, თქვენ იცით, რომ თქვენ გაქვთ JPEG ფაილის.
და მაშინ ყველა JPEG ფაილის იქნება გარკვეული ჯერადი 512 ბაიტი
მაგრამ არ ემთხვეოდეს იგივე მრავალჯერადი.
ისე, რომ თქვენ იცით, რომ თქვენ დააჭირეთ სხვა JPEG არის თუ მოხვდა კიდევ ერთი ვარსკვლავი,
სხვა დაწყებული თანმიმდევრობა bytes.
შემდეგ, რაც თქვენ აქ თქვენ გაქვთ წითელი JPEG ფაილის გაგრძელების სანამ არ მოხვდა ვარსკვლავი,
რომელიც მიერ მითითებულ ახალი ფერი.
თქვენ გაგრძელდება და მაშინ დააჭირეთ სხვა ვარსკვლავი, თქვენ მოხვდა სხვა JPEG,
თქვენ გააგრძელოს ყველა გზა ბოლომდე.
თქვენ უკანასკნელ სურათს აქ, ვარდისფერი ერთი.
მიდიხარ ბოლომდე სანამ არ მოხვდა ფაილის დასასრულს ხასიათი.
ეს იქნება მართლაც სასარგებლო.
>> რამდენიმე ძირითადი takeaways აქ:
ანკეტა ფაილი არ იწყება JPEG,
მაგრამ ერთხელ JPEG იწყება, ყველა JPEGs ინახება თალიზში ერთმანეთს.
>> ზოგიერთი pseudocode ამისთვის აღდგენა.
პირველი, ჩვენ ვაპირებთ ჩვენი გახსნა განყოფილებიდან ფაილი,
და ეს იქნება ჩვენი ფაილი I / O ფუნქციები.
ჩვენ ვაპირებთ გავიმეორო შემდეგ პროცესი, სანამ ჩვენ მიღწეული ფაილის ბოლოში.
ჩვენ ვაპირებთ წაიკითხა 512 ბაიტი დროს.
და რაც ვთქვი აქ არის ჩვენ ვაპირებთ ჩაწერს მას ბუფერული,
ასე ძირითადად გაიმართება იმ 512 ბაიტი სანამ ჩვენ ვიცით ზუსტად რა მათ.
შემდეგ, რაც ჩვენ გვსურს რომ არის ჩვენ გვინდა შევამოწმოთ თუ არა ჩვენ მოხვდა ვარსკვლავი თუ არა.
თუ ჩვენ მოხვდა ვარსკვლავი, თუ ჩვენ მოხვდა ერთ დაწყებული sequences,
მაშინ ჩვენ ვიცით, რომ ჩვენ მოხვდა ახალი JPEG ფაილის.
რა ჩვენ გვსურს რომ არის ჩვენ ვაპირებთ შევქმნა ახალი ფაილი ჩვენს pset4 დირექტორია
გააგრძელოს მიღების რომ ფაილი.
არამედ, თუ ჩვენ უკვე გააკეთა JPEG ადრე,
მაშინ ჩვენ გვინდა დასრულდეს, რომ ფაილი და დააჭირეთ მას pset4 საქაღალდეში,
სადაც ჩვენ გვექნება, რომ ფაილი ინახება, რადგან თუ ჩვენ არ დააკონკრეტა, რომ ჩვენ დასრულდა, რომ JPEG ფაილის,
მაშინ ჩვენ ძირითადად აქვს გაურკვეველი რეიტინგი თანხა. JPEGs არასდროს დასრულდება.
ამიტომ, ჩვენ გვინდა დავრწმუნდეთ, რომ როდესაც ჩვენ კითხულობს, რათა JPEG ფაილის და წერა რომ,
ჩვენ გვინდა კონკრეტულად დახურვა რომ გახსნის მიზნით მორიგი.
ჩვენ გვინდა, რომ შეამოწმოთ რამდენიმე რამ.
ჩვენ გვინდა, რომ შეამოწმოს თუ არა ჩვენ დაწყების ახალი JPEG ჩვენს ბუფერული
და ასევე თუ ჩვენ უკვე იპოვეს JPEG ადრე
იმიტომ, რომ შეიცვლება თქვენი პროცესი ოდნავ.
ასე შემდეგ თქვენ გავლა ყველა გზა და თქვენ მოხვდა ფაილის ბოლოში,
მაშინ რა თქვენ გსურთ გააკეთოთ თქვენ გსურთ დახურეთ ყველა ფაილი, რომელიც ამჟამად გახსნა.
რომ სავარაუდოდ ბოლო JPEG ფაილის რომ თქვენ გაქვთ,
ასევე განყოფილებიდან ფაილი, რომელიც თქვენ უკვე საქმე.
>> ბოლო დაბრკოლება, რომ ჩვენ გვჭირდება დაძლევის არის როგორ რეალურად მიიღოს JPEG ფაილის
და როგორ რეალურად დააყენოს იგი ფოლდერში.
Pset მოითხოვს, რომ ყველა JPEG რომ თქვენთვის იყოს შემდეგ ფორმატში,
სადაც თქვენ ნომერი. jpg.
ნომერი, ან თუნდაც 0, ჩვენ მას 000.jpg.
როდესაც თქვენთვის JPEG თქვენს პროგრამაში,
თქვენ აპირებს გვინდა ასახელებს მას იმისათვის, რომ ის ნაპოვნი.
რას ნიშნავს ეს?
ჩვენ გვჭირდება სახის ტრეკზე რამდენი ჩვენ ნაპოვნი
და რა რაოდენობის ყოველ JPEG უნდა იყოს.
აქ ჩვენ ვაპირებთ ისარგებლოს sprintf ფუნქცია.
მსგავსი printf, რომელიც მხოლოდ სახის ანაბეჭდები მნიშვნელობა შევიდა ტერმინალი,
sprintf ბეჭდავს ფაილის out შევიდა საქაღალდეში.
და მერე რა ამ ყველაფერს გააკეთებს, თუ მქონდა sprintf, სათაური, ხოლო შემდეგ სიმებიანი იქ,
ეს იქნებოდა ამობეჭდოთ 2.jpg.
თუ ვივარაუდებთ, რომ მე დაიხურა ჩემი ფაილები სწორად,
რომ შეიცავდეს ფაილი, რომელიც მე უკვე წერა გარეთ.
მაგრამ ერთი რამ არის, რომ კოდი, რომელიც მე აქ
არ საკმაოდ დააკმაყოფილოს რა pset მოითხოვს.
Pset მოითხოვს, რომ მეორე JPEG ფაილის იქნეს დასახელებული 002 ნაცვლად მხოლოდ 2.
ასე რომ, როდესაც თქვენ ამობეჭდოთ სახელი, მაშინ ალბათ დაგვჭირდება შეცვალოს placeholder ოდნავ.
>> ვინმეს ახსოვს, თუ როგორ ჩვენ არ დავუშვებთ, დამატებითი ფართები როდესაც ჩვენ ბეჭდვა რაღაც?
Yeah. >> [სტუდენტი] თქვენ დააყენა 3 შორის პროცენტით ნიშანი და 2. >> Yeah, სრულყოფილი.
თქვენ დააყენა 3 ამ შემთხვევაში, რადგან ჩვენ გვინდა ფართი 3.
% 3D ალბათ მოგცემთ 002.jpg ნაცვლად 2.
პირველი არგუმენტი შევიდა sprintf ფუნქცია ფაქტიურად char array,
რომელიც ჩვენ ადრე იცოდა როგორც სტრიქონები.
იმ ნებას, სახის უფრო დროებითი შენახვის, უბრალოდ შეინახოს resultant სიმებიანი.
თქვენ ნამდვილად არ იქნება საქმე, მაგრამ თქვენ უნდა შეიცავდეს იგი.
>> იცის, რომ ყველა ფაილის სახელი აქვს ნომერი, რომელიც იღებს სამი გმირები,
და შემდეგ. jpg, როდემდე უნდა ამ მასივი იყოს?
ჩააგდე ნომერი. რამდენი სიმბოლოების სათაური, საქართველოს სახელით?
ასე რომ არსებობს 3 hashtags, პერიოდი, jpg. >> [სტუდენტი] 7. >> 7. არ საკმაოდ.
ჩვენ ვაპირებთ მინდა 8 რადგან ჩვენ გვინდა, რომ მოხდეს null terminator ისევე.
>> საბოლოოდ, მხოლოდ შესამუშაევბლად პროცესი, რომელიც თქვენ უნდა აკეთებს აღდგენა,
თქვენ გაქვთ ზოგიერთი დასაწყისში ინფორმაციას.
თქვენ გაგრძელდება თქვენთვის დაწყების JPEG ფაილის,
და რომ შეიძლება იყოს ერთი ორი დაწყებული sequences.
თქვენ გააგრძელოს კითხულობს. ყოველი ხაზი აქ წარმოადგენს 512 ბაიტი.
თქვენ გააგრძელოს მოსმენით გააგრძელებს კითხულობს სანამ თქვენ ექმნებათ სხვა დაწყებული თანმიმდევრობით.
ერთხელ თქვენ, რომ თქვენ დასრულდება მიმდინარე JPEG - ამ შემთხვევაში, ეს წითელი ერთი,
ასე გსურთ დასრულდება, რომ.
გსურთ sprintf სახელით რომ თქვენს pset4 საქაღალდეში,
მაშინ გსურთ გახსნათ ახალი JPEG და შემდეგ გააგრძელოს კითხულობს
სანამ თქვენ ექმნებათ შემდეგი.
გააგრძელოს მოსმენით გააგრძელებს მოსმენით,
და მაშინ საბოლოოდ, საბოლოოდ, თქვენ აპირებს მიაღწიოს ფაილის დასასრულს,
და ასე რომ თქვენ გსურთ დახურეთ ბოლო JPEG, რომ თქვენ მუშაობა,
sprintf რომ თქვენს pset4 საქაღალდეში და შემდეგ შეხედეთ ყველა სურათები რომ თქვენ მიღებული.
ეს კადრები რეალურად სურათები CS50 პერსონალი,
და ამიტომ ეს არის სადაც ბონუს fun ნაწილი pset მოდის
არის, რომ თქვენ კონკურენტი თქვენს სექციები მოძიების TFs in სურათები
და ვახდენთ მათთან იმის დასამტკიცებლად, რომ თქვენ გავაკეთეთ pset
და ასე რომ თქვენ ხედავთ, რომელიც პერსონალის წევრები არიან სურათები.
ასე რომ მაშინ ვახდენთ თანამშრომლებს. ზოგჯერ თქვენ უნდა აყვანას მათ ქვემოთ.
ალბათ ზოგიერთი მათგანი შეეცდება გაქცევას თქვენგან.
თქვენ ვახდენთ მათთან.
ეს არის მიმდინარე. ეს არ არის იმის გამო, როდესაც pset გამო.
ბოლო ვადა გამოცხადდება სპეც.
მაშინ ერთად თქვენი მონაკვეთზე, რომელი მონაკვეთზე იღებს საუკეთესო სურათები
ყველაზე შემადგენლობა, გაიმარჯვებს საკმაოდ გასაოცარია პრიზი.
სწორედ ამგვარი სტიმული მიიღოთ თქვენი pset4 დასრულდა, რაც შეიძლება მალე
რადგან მაშინ შეგიძლიათ მიიღოთ ქვემოთ ბიზნეს
ნადირობს, ყველა სხვადასხვა CS50 პერსონალის წევრები.
ეს არ არის სავალდებულო, თუმცა, ასე ერთხელ თქვენ სურათები,
მაშინ დასრულდა pset4.
>> და მე დასრულდა Walkthrough 4, ამიტომ მადლობა გადაგიხადოთ ყველა მობრძანებისათვის.
წარმატებებს გისურვებთ კრიმინალისტთა. [ტაში]
[CS50.TV]