>> [მუსიკის დაკვრა]
>> Zamyla CHAN: ეს იყო მის Scarlett ერთად სასანთლე.
Whodunit?
ისე, ჩვენ ვაპირებთ გავარკვიოთ.
ამ საბჭოს თამაში ნახავ, შეიძლება მიეცეს ფიზიკური წითელი image.
და რომ სურათი არის ძალიან წითელი და spotty, და თქვენი საქმეა
გამოვლენა ფარული გაგზავნა.
და როგორც წესი, თქვენ უზრუნველყოფილი წითელი magnifying მინის, ან წითელი ეკრანზე
ცხადყოფს, რომ ჩაფლული გაგზავნა.
ისე, ჩვენ ვაპირებთ, რომ mimic რომ.
>> In whodunit, თქვენ მოცემული bitmap გამოსახულება რომ ძალიან spotty და წითელი,
და შემდეგ აწარმოებს whodunit პროგრამა გამოვლენა ფარული გაგზავნა.
>> მოდით შესვენება ამ შევიდა ნაბიჯები.
პირველი, გსურთ გახსნას ფაილი - ნახავ, რომ თქვენ მიეცა.
და შემდეგ ასევე უნდა შექმნას განაჩენი bitmap ფაილი.
მაშინ გსურთ განაახლოთ bitmap header ინფორმაცია განაჩენს outfile.
უფრო მოგვიანებით.
და მაშინ თქვენ აპირებს წაიკითხა შევიდა ნახავ, scanline, pixel მიერ pixel,
იცვლება pixel ფერები საჭიროების შემთხვევაში, და წერა
იმ შევიდა განაჩენი -
pixel მიერ pixel შევიდა განაჩენი scanline.
>> როგორ უნდა დაიწყოს აპირებს ამის შესახებ?
ისე, საბედნიეროდ, ჩვენ გვაქვს copy.c განაწილების კოდი.
და ეს ხდება იმის მტკიცება, საკმაოდ სასარგებლოა ჩვენთვის.
Copy.c იხსნება ფაილი, ნათქვამია, რომ infile მიერ header, და შემდეგ ანახლებს
outfile მიერ header.
და მერე წერია, თითოეული პიქსელის scanline, pixel მიერ pixel, და შემდეგ
წერს, რომ pixel შევიდა outfile.
>> ასე რომ, თქვენი პირველი ნაბიჯი შეიძლება უნდა აწარმოებს შემდეგ
ბრძანება ტერმინალში -
cp copy.c whodunit.c.
ეს შექმნის ასლი copy.c დაასახელა whodunit.c.
ასე რომ, ჩვენი პირველი ნაბიჯი გახსნა ფაილი, ასევე, არ არსებობს ზუსტი
რეპლიკა, რომ copy.c.
ასე რომ მე დატოვება თქვენ უნდა შევხედოთ, რომ.
>> რა ჩვენ საქმე გვაქვს ამ pset არის ფაილის I / O, ძირითადად აღების ფაილი
კითხვა, წერა, რედაქტირება მათ.
როგორ აფასებთ პირველი გახსნა ფაილი?
ისე, თქვენ აპირებს გამოაცხადოს ფაილი მაჩვენებელი, და მაშინ დარეკეთ
ფუნქცია fopen.
გაიაროს გზა, ან სახელი, რომელიც ფაილის, და შემდეგ რეჟიმი, რომელიც გსურთ
გახსნა, რომ ფაილი შემოსული
გავლის r გაიხსნება foo.bmp მოსმენით.
ვინაიდან fopen ერთად გადადის w იქნება ღია bar.bmp, წერა ფაილი და
რეალურად რედაქტირების იგი.
>> ასე რომ, ახლა რომ ჩვენ გახსნა ფაილი, ჩვენი შემდეგი ნაბიჯი არის განაახლოს header ინფორმაცია
ამისთვის outfile.
რა არის header ინფორმაცია?
ისე, პირველ რიგში, ჩვენ უნდა იცოდეს, რა bitmap არის.
Bitmap არის უბრალოდ მარტივი მოწყობის ბაიტი.
და ისინი გამოაცხადა ამ ფაილის აქ, bmp.h, ერთად bunch of
ინფორმაცია რა bitmap რეალურად გააკეთა გარეთ.
მაგრამ რაც ჩვენ ნამდვილად აინტერესებს არის Bitmap ფაილი header, სწორედ აქ, და
bitmap კარგი თავით, მეტი აქ.
Header შედგება რამდენიმე ცვლადები, რომელიც ადასტურებს, ძალიან სასარგებლო.
არსებობს biSizeImage, რომელიც სულ ზომა იმიჯი bytes.
და ამ მოიცავს პიქსელი და padding.
Padding არის ძალიან მნიშვნელოვანი, მაგრამ ჩვენ კიდევ, რომ მოგვიანებით.
>> BiWidth წარმოადგენს სიგანე იმიჯი pixels მინუს padding.
BiHeight შემდეგ ასევე სიმაღლე იმიჯი pixels.
და მაშინ BITMAPFILEHEADER და BITMAPINFOHEADER, როგორც აღვნიშნე
ადრე, იმ წარმოდგენილია როგორც structs.
ასე რომ, თქვენ ვერ შედიხართ ფაილი header თავისთავად, მაგრამ თქვენ გსურთ მიიღოთ
იმ ცვლადების შიგნით.
>> OK.
ასე როგორ უნდა განაახლოს header ინფორმაცია?
ისე, პირველ რიგში, ჩვენ უნდა ვნახოთ, თუ არა ჩვენ უნდა შეიცვალოს ნებისმიერი ინფორმაცია
infile, ნახავ, რომ outfile, განაჩენი.
არაფერი იცვლება ამ შემთხვევაში?
ისე, არ არის რეალურად, იმიტომ, რომ ჩვენ ვაპირებთ უნდა მხოლოდ იცვლება ფერები.
ჩვენ არ ვაპირებთ, შეცვლის ფაილი ზომა, გამოსახულების ზომა, სიგანე
ან სიმაღლე.
ასე რომ თქვენ ყველა უფლება ახლა მხოლოდ გადაწერა თითოეული pixel.
>> OK.
ახლა მოდით შევხედოთ, თუ როგორ ჩვენ რეალურად წაიკითხოს ყველა pixel ფაილი.
სხვა ფაილის I / O ფუნქცია მოვიდეს პიესა -
fread.
იგი იღებს მომცეთ struct , რომელშიც იქნება ბაიტი, რომ
თქვენ კითხულობთ.
ასე რომ, თქვენ კითხულობს შევიდა, რომ.
და მაშინ კორიდორი ზომა, რომელიც ზომა ყველა ელემენტს, რომ თქვენ
მინდა წაიკითხონ.
აქ, ფუნქცია sizeof მოვა მოსახერხებელი.
მაშინ კორიდორი ნომერი, რომელიც წარმოადგენს რიგი ელემენტები
ზომა წაიკითხა.
და ბოლოს, inptr, რომელიც ფაილის კურსორი, რომ თქვენ
აპირებს წაიკითხა.
ასე რომ, ყველა იმ ელემენტების შიგნით inptr და ისინი აპირებენ მონაცემები.
>> მოდით შევხედოთ პატარა მაგალითი.
თუ მე მინდა წაიკითხონ შევიდა მონაცემები ორი ძაღლი, ასევე, მე შემიძლია ამის გაკეთება ერთი ორი გზა.
მე შეგიძლიათ წაიკითხოთ ორი ობიექტები ზომა ძაღლი ჩემი inptr, ან მე წაიკითხოს
ერთი ობიექტი ზომის ორი ძაღლი იყო.
ასე რომ, თქვენ ხედავთ, რომ დამოკიდებულია გზა რომ თქვენ მოწყობა ზომის და რაოდენობის, თქვენ
შეგიძლიათ წაიკითხოთ იგივე რაოდენობის bytes.
>> ახლა, მოდით, შეცვალოს pixel ფერი გვჭირდება.
თუ გადავხედავთ bmp.h ერთხელ, მაშინ თქვენ ნახავთ, რომ ბოლოში
RGBTRIPLEs კიდევ ერთი struct, სადაც ისინი შედგება სამი ბაიტი.
ერთი, rgbtBlue, rgbtGreen და rgbtRed.
ასე რომ, თითოეული მათგანი წარმოადგენს თანხას ლურჯი, თანხის მწვანე, და
ოდენობით წითელი შიგნით ამ pixel, სადაც ყოველ წარმოდგენილია
თექვსმეტობითი ნომერი.
>> ასე ff0000 იქნება ლურჯი ფერი, რადგან ის მიდის ეხლა ლურჯი,
მწვანე, წითელი.
და მაშინ ყველა f მიერ იქნება თეთრი.
მოდით შევხედოთ smiley.bmp, რომელიც თქვენ გაქვთ თქვენი განაწილების კოდი.
თუ თქვენ გასახსნელად მხოლოდ იმიჯი მაყურებელს, მაშინ თქვენ
უბრალოდ ვხედავ წითელი smiley.
მაგრამ იმის ღრმა ჩაყვინთვის, ჩვენ ვხედავთ, რომ სტრუქტურა
ეს მხოლოდ pixels.
ჩვენ white pixels, და შემდეგ წითელი pixels.
თეთრი, ffffff, და შემდეგ ყველა წითელი pixels მე ფერადი თქვენთვის
აქ, და თქვენ ხედავთ, რომ ისინი 0000ff.
Zero ლურჯი, ნულოვანი მწვანე, და სრულ წითელი.
და რადგან smiley რვა pixels ფართო, ჩვენ არ გვაქვს რაიმე padding.
ყველა უფლება.
>> ასე რომ, თუ მე უნდა მივანიჭოთ სხვადასხვა ღირებულებების to RGBTRIPLE და მინდოდა
რათა ის მწვანე, მაშინ რა მინდა გავაკეთოთ არის მინდა განვაცხადო, RGBTRIPLE, სახელად
სამჯერ და შემდეგ შედიხართ ყველა byte ფარგლებში, რომ struct I
გამოიყენებს dot ოპერატორი.
ასე triple.rgbtBlue, შემიძლია დაავალოს, რომ 0.
Green შემიძლია მივანიჭოთ მას სრული - ნებისმიერი ნომერი, ან, მართლაც, შორის 0 და ჯ.
და მერე წითელი, მე ასევე ვაპირებ ვთქვა 0.
ასე შემდეგ, რომ მაძლევს მწვანე pixel.
>> შემდეგი, თუ მინდა შევამოწმო ღირებულება რამე?
მე შეიძლება რაღაც რომ ამოწმებს თუ არა სამჯერ მიერ rgbtBlue ღირებულება
ff და შემდეგ ბეჭდვა "მე ვარ ლურჯი ", შედეგად.
ახლა, ეს არ ნიშნავს იმას, რომ pixel არის ლურჯი, არა?
იმის გამო, რომ pixel მწვანე და წითელი ღირებულებები შეიძლება ასევე აქვს არასამთავრობო 0 ღირებულებებს.
ყველა რომ, ეს იმას ნიშნავს, და ყველა რომ ეს შემოწმება არის
სრული ლურჯი ფერი.
მაგრამ ყველა pixels შეიძლება ასევე აქვს არასრული, ფერი ღირებულებებს, როგორც ეს
შემდეგი მაგალითი აქ.
>> ეს ცოტა რთული ვხედავ რა ეს გამოსახულება არის.
ეს გამოიყურება ცოტა მეტი მოსწონს clue.bmp, რომ თქვენ მოგეცემათ.
ახლა, ფიზიკურად, თქვენ შეიძლება მოსაგვარებლად, იმიტომ, რომ იქ ბევრი წითელი, by
ჩატარების წითელი ეკრანზე გამოსახულება ისე, რომ სხვა ფერები შეიძლება გამოჩნდება.
ასე როგორ უნდა mimic ამ c?
ასევე, ჩვენ შეიძლება ამოიღონ ყველა წითელი იმიჯი მთლიანად.
და ასე უნდა გავაკეთოთ, რომ ჩვენ გვინდა მითითებული ყველა pixel წითელი მნიშვნელობა 0.
და ასე გამოსახულება გამოიყურება პატარა ცოტა მოსწონს, სადაც ჩვენ არ გვაქვს წითელი
განაწილებაზე.
>> ჩვენ ვხედავთ, ფარული გაგზავნა ცოტა უფრო ნათლად არის.
ეს არის კიდევ ერთი smiley face.
ან იქნებ ჩვენ შეგვიძლია გამოვიყენოთ სხვა მეთოდი.
იქნებ, ჩვენ ვერ იდენტიფიცირება ყველა წითელი pixels -
რომ არის, ყველა pixels ერთად 0 ლურჯი, 0 მწვანე და 0 წითელი -
და შეცვალოს იმ თეთრი.
და ჩვენი იმიჯი შეიძლება გამოიყურებოდეს რაღაც მსგავსი.
ცოტა ადვილი ვხედავ.
>> არსებობს უამრავი სხვა გზები, რათა uncover საიდუმლო გაგზავნა, ისევე,
საქმე ფერი მანიპულირება.
იქნებ თქვენ შეიძლება გამოიყენოთ ერთი მეთოდი რომ ზემოთ აღვნიშნე.
და დამატებით, დაგვჭირდება გააძლიეროს ზოგიერთი ფერები
და მოიტანს იმ out.
>> ასე რომ, ახლა რომ ჩვენ შეიცვალა pixel ფერი, შემდეგ ჩვენ უბრალოდ უნდა დაწეროთ მათ
იმ scanline, pixel მიერ pixel.
და კიდევ ერთხელ, თქვენ გსურთ ვიხსენებთ to copy.c, თუ არ გადაწერა
ეს უკვე, და შევხედოთ fwrite ფუნქცია, რომელიც იღებს მონაცემებს, მომცეთ
რომ struct, რომელიც შეიცავს bytes რომ თქვენ კითხულობს, ზომა
ელემენტი, რაოდენობის ნივთები, და მაშინ outptr -
დანიშნულების იმ ფაილებს.
>> შემდეგ წერთ იმ pixels, თქვენ ასევე უნდა ჩაიწეროს, padding.
რა არის padding?
ისე, ყველა rgbt pixel სამი ბაიტი ხანგრძლივი.
მაგრამ, scanline განთავსების bitmap გამოსახულება უნდა იყოს მრავალჯერადი ოთხი bytes.
და თუ ნომერი pixels არ არის მრავალჯერადი ოთხი, მაშინ ჩვენ უნდა დაამატოთ
ამ padding.
Padding მხოლოდ წარმოდგენილია 0S.
ასე რომ, როგორ უნდა დაწეროთ, ან წაიკითხა ეს?
ასევე, ირკვევა, რომ თქვენ ვერ რეალურად fread padding, მაგრამ შეგიძლიათ
გამოვთვალოთ იგი.
>> ამ შემთხვევაში, ნახავ და განაჩენი აქვს იგივე სიგანე, ისე
padding არის იგივე.
და padding, როგორც თქვენ ნახავთ in copy.c, გამოითვლება
ერთად ქვემოთ ფორმულა -
bi.biWidth ჯერ sizeof (RGBTRIPLE) იქნება გვაძლევს რამდენი ბაიტი bmp
აქვს ყველა row.
იქიდან, modulos და subtractions 4 შეგვიძლია გამოვთვალოთ რამდენად
ბევრი bytes უნდა დაემატოს ისე, რომ მრავალჯერადი ბაიტი on
ყოველ ზედიზედ ოთხი.
>> ახლა რომ ჩვენ გვაქვს ფორმულა რამდენად padding გვჭირდება, ახლა
ჩვენ შეგვიძლია დაწერა.
ახლა, მე აღვნიშნეთ, padding მხოლოდ 0S.
ასე რომ, ამ შემთხვევაში, ჩვენ უბრალოდ აყენებს char, ამ შემთხვევაში 0, ჩვენს
outptr - ჩვენი outfile.
ასე რომ, შეგიძლიათ უბრალოდ იყოს fputc 0, მძიმე outptr.
>> ასე რომ, ხოლო ჩვენ უკვე კითხულობს ჩვენს ფაილი, ფაილის I / O ინახება სიმღერა ჩვენი
პოზიცია იმ ფაილებს რაღაც ე.წ. ფაილის პოზიცია მაჩვენებელი.
ვფიქრობ, რომ ეს კურსორი.
ძირითადად, ეს ავანსები ყოველ ჯერზე რომ ჩვენ fread, მაგრამ ჩვენ გვაქვს
კონტროლი, ძალიან.
>> გადაადგილება ფაილი თანამდებობა მაჩვენებელი, თქვენ შეგიძლიათ გამოიყენოთ ფუნქცია fseek.
სადაც inptr წარმოადგენს ფაილი მაჩვენებელი, რომ თქვენ ეძებს წელს,
თანხა ბაიტების რაოდენობას, რომ თქვენ მინდა გადატანა კურსორი და შემდეგ
ეხება ათვლის სადაც კურსორი არის.
თუ გაივლის SEEK_CUR, რომელიც წარმოადგენს მიმდინარე
პოზიცია ფაილი.
ან შეგიძლიათ გამოიყენოთ ზოგიერთი სხვა პარამეტრებს.
ასე რომ, ჩვენ დაგვჭირდება გამოვიყენოთ fseek გამოტოვოთ მეტი padding, რომ ფაილი.
ისევ და ისევ, თუ თქვენ დავრჩებოდით, არსებობს მაგალითი, რომ copy.c.
>> ახლა ჩვენ გახსნა ფაილი, ნახავ და განაჩენი.
ჩვენ განახლებული header ინფორმაციის ჩვენი განაჩენი, რადგან ყველა
bitmap სჭირდება header.
ჩვენ შემდეგ წაიკითხა შევიდა ნახავ მიერ scanline, pixel მიერ pixel, იცვლება
ყველა ფერი, როგორც საჭიროა, და წერა იმ შევიდა
განაჩენი, pixel მიერ pixel.
მას შემდეგ, რაც თქვენ გახსნა განაჩენი, ხედავთ, ვინც დამნაშავეებმა, ან რა საიდუმლო
გაგზავნა არის.
ჩემი სახელი არის Zamyla, და ეს იყო whodunit.