[Powered by Google Translate] [Tutorial - Joc Problema 4]
[Zamyla Chan - Harvard University]
[Aquesta és CS50. - CS50.TV]
Està bé. Hola a tots i benvinguts a Tutorial 4.
>> Avui el nostre conjunt de processadors és Forensics.
Forense és un conjunt de processadors molt divertit que consisteix en tractar amb arxius de mapa de bits
per descobrir que ha comès un crim.
A continuació, anem a canviar la mida d'alguns arxius de mapa de bits,
llavors nosaltres també farem front a una part molt divertit anomenat Recuperar,
en què estem, bàsicament, va lliurar una targeta de memòria
en què algú ha esborrat accidentalment tots els seus arxius,
i se'ns demana que recuperar aquests arxius.
>> Però primer, abans d'entrar en el conjunt de processadors, realment només vull felicitar a tothom.
Estem a punt al punt mitjà d'aquest curs.
Quiz 0 està darrere de nosaltres, i estem en pset4, pel que en essència, estem a mig camí.
Hem recorregut un llarg camí si un mira cap enrere els seus conjunts de processadors, pset0 i pset1,
així que felicitar per això,
i entrarem en algunes coses realment divertides.
>> Així que la nostra caixa d'eines per a aquest conjunt de processadors, de nou, en lloc d'executar sudo yum-i update,
estem en condicions d'executar només update50 si vostè està en la versió 17.3 i superior de l'aparell.
Així que assegureu-vos d'executar update50 - és un fàcil molt, uns pocs caràcters poc -
per assegurar-se que vostè està en l'última versió de l'aparell.
Sobretot és important update50 quan vam començar a utilitzar CS50 Check.
Així que assegura't que ho fas.
>> Per a totes les seccions d'aquest conjunt de processadors,
estarem tractant amb entrades i sortides d'arxius, arxivar I / O.
Anem a anar a través d'una gran quantitat de programes que tenen a veure amb els arranjaments
apunta a arxius i coses per l'estil,
pel que volem assegurar-nos que estem molt familiaritzats i còmodes
tractar amb la forma d'entrada i sortida en els arxius.
>> En el codi de distribució per al conjunt de processadors és un arxiu anomenat copy.c,
i això és el que trobarem serà molt útil per a nosaltres
perquè anem a acabar copiant l'arxiu copy.c
i només es modifiquen lleugerament per ser capaç d'aconseguir els primers 2 parts del conjunt de problemes.
>> I llavors, com he dit abans, es tracta de mapes de bits, així com JPEG.
Així que en realitat la comprensió de l'estructura de com s'organitzen els arxius,
com realment podem traduir el 0 i 1 en les estructures
i les coses que en realitat podem entendre i interpretar i editar,
que serà molt important,
així que anar en JPEG i arxius de mapa de bits i la comprensió de l'estructura d'aquests.
>> Pset4, com de costum, comença amb una secció de preguntes.
Els que s'ocuparà d'arxiu d'E / S i aconseguir que acostumats a això.
A continuació, la part 1 és Qui ho va fer, en el qual se't dóna un arxiu de mapa de bits
que es veu una mica com punts vermells per tot arreu.
I bàsicament el que farem és prendre aquest arxiu i editar només lleugerament
en una versió que es pot llegir.
Bàsicament, un cop que acabem, tindrem el mateix arxiu,
excepte que serà capaç de veure el missatge ocult amagat per tots els punts vermells.
Llavors Resize és un programa que, donat un arxiu
i després es dóna el nom de l'arxiu que s'envia i se li dona un número així,
realitat que canvia la mida de mapa de bits que valor sencer.
Llavors, finalment, tenim el conjunt de processadors Recover.
Se'ns ha donat una targeta de memòria i després haver de recuperar totes les fotos
que han estat esborrats accidentalment,
però, com anem a aprendre, no elimina realment i s'elimina l'arxiu;
simplement una mica perdut en el qual es trobaven a l'arxiu, però anem a recuperar això.
>> Gran. Així que va a l'arxiu d'E / S en concret, es tracta de tota una llista de funcions que s'utilitzarà.
Ja has vist una mica els fonaments de fopen, fread, fwrite, i
però anem a aprofundir en algun arxiu d'E / S funciona com fputc,
en el qual acaba d'escriure un caràcter alhora,
a fseek, on es mou el tipus d'indicador de posició del fitxer endavant i cap enrere,
i després alguns altres. Però entrarem en això una mica més tard, durant el conjunt de processadors.
>> Així que primer, només per entrar a l'arxiu d'E / S abans d'entrar en el conjunt de processadors,
per obrir un arxiu, per exemple, el que has de fer és establir realment un punter a aquest arxiu.
Així que tenim un punter FILE *.
En aquest cas, estic cridant un punter perquè això serà la meva infile.
Així que vaig a utilitzar la funció fopen i després el nom de l'arxiu
i llavors la manera en què jo vaig a estar tractant amb l'arxiu.
Així que hi ha "r" en aquest cas per a la lectura, "w" per a escriptura, i després "a" per annexar.
Per exemple, quan vostè està tractant amb un infile
i tot el que vols fer és llegir els bits i els bytes emmagatzemats allà,
llavors vostè està probablement va a voler utilitzar "r" com la seva manera.
Quan vulgui escriure en realitat, una espècie de fer un nou arxiu,
llavors el que farem és que anem a obrir el nou arxiu
i l'ús de la "w" manera d'escriptura.
>> Així que quan vostè està en realitat la lectura en els arxius, l'estructura és la següent.
En primer lloc s'inclou el punter a l'estructura que conté els bytes que vostè està llegint.
Així que serà la ubicació final dels bytes que s'està llegint.
Estàs passant després a indicar la mida, igual que, bàsicament, la quantitat de bytes
el seu programa ha de llegir a l'arxiu, la mida, bàsicament, un element és,
i llavors vostè va a especificar quants elements desitjada.
I finalment, vostè ha de saber on vostè present,
així que això serà el punter a.
I codificats per color aquests perquè fread és també molt similar a fwrite,
llevat que vostè vol assegurar-se que s'utilitza l'ordre correcte,
assegurar-se que en realitat estàs escrivint o llegint des de l'arxiu correcte.
>> Així que, com abans, si tenim la mida de l'element, així com el nombre d'elements,
llavors podem jugar aquí una mica.
Dir que tinc una estructura GOS I llavors vull llegir dos gossos alhora.
El que podria fer és dir la mida d'un element que serà de la mida d'un gos
i jo vaig a llegir realment dos.
D'altra banda, el que podria fer és dir que només vaig a llegir un dels elements
i que un element serà la mida de dos gossos.
Així que això és anàloga com pot tipus de joc una mica amb la mida i el nombre de
depenent del que és més intuïtiu per a vostè.
>> Està bé. Ara arribem als arxius d'escriptura.
Per escriure un arxiu, el primer argument és en realitat on vostè està llegint.
Així que això és, bàsicament, les dades que es van a escriure en el fitxer,
que és el punter al final.
Així que quan vostè està tractant amb el conjunt de processadors, assegureu-vos que no es confonguin.
Potser tenir el costat definicions a costat.
Pot estirar les definicions al manual teclejant man i fwrite, per exemple,
a la terminal, o pot referir-se a aquesta diapositiva
i assegureu-vos que utilitzeu la correcta.
Així que de nou, per fwrite, quan vostè té un arxiu que es vol escriure en,
que serà l'últim argument i això serà un punter a aquest arxiu.
Així que això és el que tractem d'escriure potser multibytes alhora,
però diu que vol escriure just en només un caràcter únic.
Com veurem més endavant en aquest exemple, en els mapes de bits que haurem de fer servir això.
És llavors quan podem utilitzar fputc, essencialment només posar un caràcter alhora, chr,
al punter d'arxiu, i aquest és el nostre punter per aquí.
Així que cada vegada de buscar o escriure en un arxiu,
l'arxiu és no perdre de vista on estem.
Així que és una mena de cursor, l'indicador de posició de l'arxiu.
I així, cada vegada que escrivim o llegim de nou en un arxiu,
l'arxiu realment recorda on està,
i pel que continua des d'on està el cursor.
Això pot ser beneficiós quan es vol, per exemple, llegir en una certa quantitat per fer alguna cosa
i després llegir en les següents quantitats,
però de vegades pot ser que vulgui tornar o en realitat parteixen d'un valor de referència determinat.
Llavors la funció fseek, el que fa és que ens permet moure el cursor en un determinat arxiu
un cert nombre de bytes.
I llavors el que hem de fer és especificar que el valor de referència és.
Així que, o es mou cap endavant o cap enrere des de la posició del cursor en l'actualitat és,
o es pot especificar que només s'ha de moure des del principi de l'arxiu
o des del final de l'arxiu.
I pel que pot passar en valors negatius o positius a quantitat,
i que classe de moure el cursor cap endavant o cap enrere.
>> Abans d'entrar en els conjunts de processadors altres preguntes a l'arxiu I / O?
Bé. En entrar en més exemples, no dubti en deixar de fer preguntes.
>> Així que en Whodunit, et va lliurar un arxiu de mapa de bits similar a aquesta xarxa a la diapositiva,
i sembla que això - un munt de punts vermells - i no se sap molt bé el que està escrit.
Si escodrinya, vostè pot ser capaç de veure un lleuger color blavós a l'interior del centre.
En essència, això és on el text s'emmagatzema.
Hi va haver un assassinat que va ocórrer, i hem de saber qui ho va fer.
Per tal de fer això, hem de convertir aquesta espècie d'imatge en un format llegible.
Si vostès he trobat això, de vegades no hi hauria kits petits
on tindria una lupa amb una capa de color vermell. Algú? Si.
Així que seria alguna cosa com això sola mà, vostè tindria una lupa
amb la pel · lícula de color vermell sobre ell, el posaria sobre la imatge,
i que seria capaç de veure el missatge ocult en ella.
No tenim una lupa amb pel · lícula vermell, així que en comptes que anem a la classe de crear el nostre propi
en aquest conjunt de processadors.
I així, l'usuari va a whodunit entrada, llavors la pista,. Bmp,
així que aquesta és la infile, aquest és el missatge de punt vermell,
i llavors ells estan dient verdict.bmp serà el nostre arxiu de sortida.
Així que crearà una imatge de mapa de bits similar a la idea d'una
excepte en un format llegible en el qual podem veure el missatge ocult.
>> Ja que estarem tractant amb l'edició i manipulació de mapes de bits d'algun tipus,
anem a classe de busseig a en l'estructura d'aquests arxius de mapa de bits.
Vam anar poc aquestes una mica en la conferència, però anem a veure-hi una mica més.
Els mapes de bits són essencialment només un arranjament de bytes
on hem especificat què significa el octets.
Així que aquí és com un mapa de la imatge de mapa de bits
dient que s'inicia amb alguns arxius de capçalera, s'inicia amb una mica d'informació en aquest país.
Ja veus que a això de byte número 14 s'indica la mida de la imatge de mapa de bits,
i es continua.
Però el que realment estem interessats aquí està començant voltant del nombre de bytes 54.
Tenim aquests triples RGB.
El que farà és contenir els píxels reals, els valors de color.
Tot això que en la capçalera és informació
corresponent a la de la imatge, l'amplada de la imatge, i l'altura.
Quan entrem en el farciment més tard, veurem per què la mida de la imatge
pot ser diferent de l'amplada o l'alçada.
Així que per representar aquests - aquestes imatges de mapa de bits són seqüències de bytes -
el que podem fer és dir bé, jo recordaré que en l'índex 14,
aquí és on la mida és, per exemple, però en canvi el que farem perquè això sigui més fàcil
està encapsulat en una estructura.
I així tenim dues estructures fetes per a nosaltres, un BITMAPFILEHEADER
i un BITMAPINFOHEADER,
i així cada vegada que llegim a aquest arxiu, per defecte que anirà en ordre,
i el que per a ella també va a omplir en variables com ara biWidth i biSize.
I, finalment, cada píxel està representat per tres bytes.
La primera és la quantitat de blau al píxel, el segon és la quantitat de verd,
i finalment, la quantitat de vermell, on 0 és essencialment no verd blau o no o no vermella
i després ff és el valor màxim.
Aquests són valors hexadecimals.
Així que si tenim ff0000, llavors correspon a la quantitat màxima de blau
i després no hi ha verd i vermell no, és així, que ens donaria un píxel blau.
Llavors, si tenim tota ff a tots els terrenys, llavors això vol dir que tenim un píxel blanc.
Això és una mica contrari al general, quan diem RGB. En realitat va BGR.
>> Així que si realment es veuen en un exemple d'una imatge de mapa de bits - vull una tirada aquí.
És una mica petita.
Estic un acostament, i podem veure que està pixelada. Sembla que els blocs de color.
Vostè té blocs blancs i després els blocs vermells.
Si jugues a Microsoft Paint, per exemple, vostè podria fer el mateix
bàsicament per pintar alguns quadrats en un ordre específic.
Així que el que es tradueix en el mapa de bits és la següent.
Aquí tenim primer píxels blancs, que són totes les 6 f, i llavors tenim píxels vermells,
indicat per 0000ff.
I així, la seqüència de bytes que tenim indica com la imatge de mapa de bits es veurà.
Així que el que hem fet aquí és només per escrit amb tots aquests bytes i després es pinta en vermell
perquè pugui classe de veure, si vostè escodrinya una mica, com aquest tipus d'indica una cara somrient.
>> La manera com el treball de les imatges de mapa de bits que és bàsicament l'imaginem com una quadrícula.
I així, per defecte, cada fila de la graella ha de ser un múltiple de 4 bytes.
Si ens fixem en una imatge de mapa de bits, que està omplint cada valor.
Per exemple, podeu tenir un vermell per aquí, un verd aquí, un blau aquí,
però vostè ha de assegurar-se que la imatge es completa amb un múltiple de quatre bytes.
Així que si vull que la meva imatge sigui tres quadres d'ample, llavors jo hauria de posar un valor buit
en l'últim perquè sigui un múltiple de quatre.
Així que m'agradaria afegir una cosa en què estem cridant farcit.
Jo només vaig a indicar que hi ha amb una x.
Ara diem que volem una imatge que és de 7 píxels de llarg, per exemple.
Tenim 1, 2, 3, 4, 5, 6, 7,
i tot això s'omple amb el color.
La manera com les imatges de mapa de bits funciona és que necessitem una octava.
Ara tenim 1, 2, 3, 4, 5, 6, 7.
Necessitem 8 espais per a la imatge de mapa de bits a llegir correctament.
Així que el que hem de fer és afegir en tan sols una mica de farciment
per assegurar-se que totes les amplades són uniformes
i que totes les amplades són un múltiple de 4.
I així s'ha indicat anteriorment, el farciment com una X o una línia ondulada,
però en les imatges de mapa de bits reals el farciment s'indica mitjançant un 0 hexadecimal.
Així que seria un personatge únic, 0.
El que podria ser útil és la comanda xxd.
El que fa és en realitat mostra que, igual que similar al que feia abans amb el smiley
quan en realitat el que imprimeix cada color seria per al píxel
i després un codi de colors, quan s'executa xxd amb els següents comandaments,
llavors en realitat s'imprimirà el que els colors són per a aquells píxels.
El que has de fer és indicar aquí que, igual que la s-54
diu que jo vaig a començar pel byte 54
perquè abans d'això, recordeu que si mirem enrere per al mapa dels mapes de bits,
aquesta és tota la informació de capçalera i coses per l'estil.
Però el que realment importa és els píxels reals que indiquen el color.
Per tant afegint en aquesta bandera,-s 54, llavors som capaços de veure els valors de color.
I no et preocupis per les banderes complicades i coses per l'estil.
En l'especificació del conjunt de problemes, tindrà instruccions sobre com utilitzar xxd per mostrar els píxels.
Així que si vostè veu aquí, és com que s'assembla a una caixa verda, això és poca cosa.
He codificat per colors com el 00FF00 bàsicament dient que no blau, molt verd i vermell no.
Així que correspon a verd.
Com es veu aquí, veiem un rectangle verd.
Aquest rectangle verd és a 3 píxels d'ample, de manera que llavors el que hem de fer
per assegurar-se que la imatge és un múltiple de 4 d'ample és afegir en un encoixinat addicional.
I llavors així és com es veu aquests 0s aquí.
En realitat, això és el resultat del seu conjunt de processadors de mida,
essencialment prendre la petita mapa de bits i després ampliar per 4.
I així, el que veiem és que en realitat aquesta imatge és de 12 píxels d'amplada, però 12 és un múltiple de 4,
pel que en realitat no veig cap 0s al final perquè no cal afegir cap
perquè està totalment encoixinat. No té sala més.
>> Bé. Qualsevol pregunta sobre farcit?
Bé. Cool.
>> Com he esmentat abans, els mapes de bits són més que una seqüència de bytes.
I així, el que tenim és en lloc d'haver de portar un registre d'exactament quin nombre de bytes
correspon a un element específic, que en realitat han creat una estructura per representar això.
Així que el que tenim és una estructura RGBTRIPLE.
Sempre que tingui una instància d'un triple RGB,
perquè es tracta d'un tipus struct defineix, llavors vostè pot accedir a la variable rgbtBlue,
de manera similar les variables de verd i vermell, que indiquen la quantitat de blau, verd i vermell
respectivament, que vostè té.
>> Així que si tenim la variable de blau a 0, el conjunt verd a ff,
que és el valor màxim que pot tenir, i llavors la variable vermell ajustat a 0,
llavors, ¿quin color seria el particular triples RGB representa? >> [Estudiant] Green.
Green. Exactament.
Serà útil saber que cada vegada que tingui una instància d'un triple RGB,
en realitat es pot accedir a la quantitat de color - blau, verd i vermell - per separat.
>> Ara que hem parlat de l'estructura d'això, anem a fer una ullada a l'arxiu BMP.
Aquestes són estructures fetes per a vostè.
Aquí tenim una estructura BITMAPFILEHEADER.
D'interès és la mida.
Més tard, tenim la informació de capçalera, que té un parell de coses més que són interessants per a nosaltres,
a saber, la grandària, l'amplada, i l'alçada.
Com entrarem en més tard, quan es llegeix a l'arxiu,
es llegeix automàticament en perquè hem creat l'ordre de ser el mateix.
Així la biSize contindrà els bytes adequades que es corresponen amb la mida real de la imatge.
I aquí, finalment, com ja hem parlat, tenim el typedef struct RGBTRIPLE.
Tenim una rgbtBlue, verd i vermell associat a ell.
>> Gran. Bé.
Ara que entenem els mapes de bits una mica, entenem que tenim un arxiu de capçalera
i una capçalera d'informació de la mateixa i després d'això, tenim les coses interessants
dels colors, i els colors estan representats per les estructures RGBTRIPLE,
i els que, al seu torn, té tres valors associats a la blava, el verd i el vermell.
>> Així que ara, podem pensar en classe de recuperar una mica.
Em sap greu. Penseu Whodunit.
Quan tenim el nostre arxiu de pista, llavors el que volem fer és llegir-hi píxel per píxel
i llavors d'alguna manera canviar els píxels de manera que puguem donar sortida a un format llegible.
I així, per donar sortida, escriurem píxel per píxel a l'arxiu verdict.bmp.
Això és una mica molt per fer. Ens adonem d'això.
Així que el que hem fet és que hem fet li va proporcionar copy.c.
El que fa és copy.c només fa una còpia exacta d'un arxiu de mapa de bits donat i després l'emet.
Així que això ja s'obre l'arxiu per a vostè, es llegeix en píxel per píxel,
i llavors s'escriu en un arxiu de sortida en.
>> Anem a fer una ullada a això.
Aquesta és assegurar l'ús adequat,
obtenir els noms dels arxius aquí.
El que això fa és que estableix el fitxer d'entrada sigui el que hem passat al infile aquí,
que és el nostre segon argument de línia d'ordres.
S'assegura que puguem obrir l'arxiu.
Xecs per assegurar-nos que podem fer un nou arxiu de sortida aquí.
Llavors, què fa aquest aquí, només, bàsicament, comença a llegir a l'arxiu de mapa de bits des del principi.
El començament, com sabem, conté el BITMAPFILEHEADER,
i pel que aquestes seqüències de bits directament completarà el BITMAPFILEHEADER.
Així que el que tenim aquí està dient que bf BITMAPFILEHEADER -
aquesta és la nostra nova variable de tipus BITMAPFILEHEADER -
posarem dins bf el que llegim de punter, que és el nostre infile.
Quant llegim?
Llegim en la quantitat de bytes que necessitem per contenir el BITMAPFILEHEADER conjunt.
De la mateixa manera, això és el que fem per la informació de capçalera.
Així que seguim al llarg del nostre arxiu al infile,
i ens estem llegint els bits i bytes, i els estem connectant directament en
en aquests casos de les variables que estem fent.
Aquí només estem assegurant que el mapa de bits és un mapa de bits.
>> Ara tenim un arxiu de sortida, no?
Així que tal com està quan ho creguem, és essencialment buit.
Així que hem de crear un nou mapa de bits, bàsicament, a partir de zero.
El que fem és que ens hem d'assegurar de copiar a l'arxiu de capçalera
i la informació de capçalera igual que el infile té.
El que fem és escriure - i recordi que bf és la variable
de BITMAPFILEHEADER tipus, així que el que fem és que només ha d'utilitzar aquest contingut
per escriure al fitxer de sortida.
En aquest sentit, recordo que parlem sobre el farciment,
com és important assegurar-se que la quantitat de píxels que tenim és un múltiple de 4.
Aquesta és una fórmula molt útil per calcular la quantitat de farciment que té
donada l'amplada del seu arxiu.
Jo vull que vostès recordin que en copy.c tenim una fórmula per al càlcul de farciment.
¿D'acord? Així que tothom recorda això. Gran.
Llavors, què fa copy.c següent és que es repeteix en totes les línies d'exploració.
Passa a través de les files primera i després emmagatzema cada triple que es llegeix
i llavors s'escriu al fitxer de sortida.
Així que aquí estem llegint només un triple de RGB alhora
i després posar que Triple mateixos a l'arxiu de sortida.
La part difícil és que el farciment no és un triple RGB,
i per tant no podem llegir aquesta quantitat de farcit triples RGB.
El que hem de fer és en realitat només moure el nostre indicador de posició del fitxer, desplaçar el cursor,
al tipus de saltar tot el farciment de manera que estem a la fila següent.
I llavors el que fa és copiar mostra com és possible que vulgueu afegir el farcit.
Per això hem calculat la quantitat de farciment que necessitem,
el que significa que necessitem encoixinat nombre de 0s.
El que fa és un bucle que situa el nombre de 0s encoixinat al nostre arxiu de sortida.
I, finalment, es tanca dos arxius. Es tanca el infile així com l'arxiu de sortida.
>> Així és com funciona copy.c,
i això serà molt útil.
En comptes de en realitat directament copiar i enganxar
o simplement mirar i escriure el que vulguis,
molts de vosaltres voleu per executar aquesta comanda a la terminal,
cp copy.c whodunit.c i això tindrà un nou arxiu, whodunit.c,
que inclou el contingut exactament com còpia ho fa.
Així que el que podem fer és usar això com una base sobre la qual construir i editar
per al nostre arxiu novel · la policíaca.
>> Aquestes són les nostres tasques pendents de fer per Whodunit, però què copy.c
en realitat s'encarrega de la major part d'ells per a nosaltres.
Així que tot el que hem de fer ara és canviar els píxels segons sigui necessari
per fer realitat el fitxer de lectura.
Recordeu que per a un píxel donat, triple, així que per a una variable donada d'RGBTRIPLE tipus,
pot accedir als valors de blau, verd i vermell.
Això serà molt útil perquè si es pot accedir a ells,
que significa que també es pot comprovar,
i això vol dir que també es pot canviar.
>> Així que quan vam tornar al nostre exemple vermell lupa,
bàsicament, que actuava com una mena de filtre per a nosaltres.
Així que el que vull fer és que volem filtrar tots els triples que vénen polz
Hi ha diverses maneres de fer això.
Bàsicament, vostè pot tenir qualsevol tipus de filtre que desitgi.
Potser vostè vol canviar tots els píxels vermells
o potser voleu canviar un píxel de color a un color diferent.
Això depèn de tu.
Recordi que vostè pot veure que el color del píxel és
i també es pot canviar a mesura que estàs passant.
>> Bé. Així que això és Whodunit.
Quan executi Qui ho va fer, vostè sabrà qui és el culpable del crim era.
>> Ara anirem a canviar la mida.
Anem a encara estar tractant amb mapes de bits.
El que farem és que tindrem un mapa de bits d'entrada
i després passarem a un nombre i obtenir un mapa de bits archivosalida
on això és bàsicament el nostre infile escalat per n.
Vaig donar la meva arxiu era només un píxel gran.
Llavors, si el meu n va ser de 3, escalat per 3, llavors m'agradaria repetir aquest píxel n nombre de vegades,
per la qual cosa 3 vegades, i després també redueix l'escala 3 vegades també.
Així que ja veus que estic escalant tant vertical com horitzontalment.
>> I heus aquí un exemple.
Si té n = 2, es veu que el píxel blau principi no va repetir dues vegades
tant horitzontal com verticalment dues vegades.
I després que segueix endavant, i perquè tingui una ampliació directa de la imatge original en dues.
>> Així que si ens anàvem a detall el pseudocodi per això, volem obrir l'arxiu.
I després, sabent que si tornem aquí,
veiem que l'amplada per l'arxiu de sortida que serà diferent de l'amplada de la infile.
Què significa això?
Això vol dir que la nostra informació de capçalera es canviarà.
I què hem de voler fer és actualitzar la informació de la capçalera,
sabent que quan llegim en els arxius si vostè està treballant en el marc copy.c,
ja tenim una variable que indica quin és la mida és i coses així.
Així que un cop aconseguit això, el que pot voler fer és canviar aquestes variables particulars.
Recordi, si vostè té una estructura, com s'accedeix a les variables dins d'això.
S'utilitza l'operador punt, no?
Així que amb això, ja saps que hauràs de canviar la informació de la capçalera.
Així que aquesta és només una llista dels elements reals que es canviaran a l'arxiu.
La mida de l'arxiu que es va a canviar, la imatge, així com l'amplada i l'alçada.
Així que tornar al mapa dels mapes de bits,
veure si es tracta de la capçalera de l'arxiu o la informació de capçalera que conté aquesta informació
i després canviar segons sigui necessari.
Una vegada més, per exemple cp copy.c resize.c.
Això vol dir que resize.c ara conté tot el que està contingut a l'interior còpia
còpia perquè ens proporciona una forma de lectura en línia d'exploració a cada píxel a píxel.
Només que ara, en comptes de canviar els valors com ho vam fer en Whodunit,
el que volem fer és que volem escriure en diversos píxels
mentre el nostre n és més gran que 1.
>> Llavors el que vull fer és el volem estirar horitzontalment per n,
així com que s'estenen verticalment per n.
Com podem fer això?
Diguem que el seu n és 2 i que té esta donat infile.
El cursor es començarà pel primer,
i el que vol fer si n és 2, que voleu imprimir en 2 d'ells.
Així d'imprimir en dos d'ells.
A continuació, el cursor es passarà a la següent píxel, que és el vermell,
i que voleu imprimir 2 de aquests vermells, afegint que en el que ha fet abans.
A continuació, el cursor es mourà a la següent píxel i dibuixar en 2 d'ells.
Si es mira de nou a la copy.c marc, el que això fa aquí
es crea una nova instància d'un triple RGB, una nova variable anomenada triple.
I aquí quan llegeix-hi, ho fa des de l'1 infile RGBTRIPLE
i s'emmagatzema en l'interior d'aquesta variable triple.
Així que en realitat té una variable que representa aquest píxel en particular.
Llavors, quan vostè escriu, el que pot voler fer és tancar la declaració fwrite en un bucle for
que escriu en el seu arxiu de sortida tantes vegades com sigui necessari.
Això és bastant simple.
Així, bàsicament, repeteixi el procés d'escriptura núm nombre de vegades per escalar horitzontalment.
>> Però hem de recordar que el nostre farcit es canviarà.
Abans, dir que vam tenir una mica de longitud 3.
Llavors ens tornaríem a afegir en el farciment? Només un més perquè sigui un múltiple de 4.
Però dir que estem escalant aquesta imatge en particular per n = 2.
Llavors quants píxels blaus tindríem al final? Hauríem 6.
1, 2, 3, 4, 5, 6. Està bé.
6 no és un múltiple de 4. Quin és el més proper múltiple de 4? Això serà 8.
Així que estem realment tindrà dos caràcters de farciment allà.
>> Algú recorda si tenim una fórmula per calcular el farciment
i on podria estar?
[Resposta dels estudiants inaudible] >> Sí, copy.c. Dreta.
Hi ha una fórmula en copy.c per calcular la quantitat de farciment que té
donat una amplada particular de la imatge de mapa de bits.
Així que serà útil quan es necessita afegir en una certa quantitat de farcit
d'entendre realment a terme el farciment ha de afegir.
Però una nota, però, és que vostè vol assegurar-se que vostè està utilitzant la mida correcta.
Només vés amb compte perquè estàs bàsicament estarà tractant amb dues imatges de mapa de bits.
Vostè vol assegurar-se que utilitzeu la correcta.
Quan vostè està calculant el farciment per l'arxiu de sortida, que desitja utilitzar tot l'ample de l'arxiu de sortida
i no l'ample de l'anterior.
>> Gran. Aquest tipus d'estirament es fa càrrec d'una imatge de mapa de bits total horitzontalment.
Però el que vull fer és realment estirar verticalment també.
Això serà una mica més complicat perquè quan hem acabat de copiar una fila
i escriure aquesta fila, el nostre cursor estarà a l'extrem.
Així que si tornem a llegir, llavors només va a llegir a la següent línia.
Així que el que vull fer és una espècie de trobar alguna manera de copiar les files de nou
o simplement prendre aquest tipus de fila i després tornar a escriure de nou.
Com tipus d'al · lusió, hi ha diverses maneres de fer això.
El que podria fer és que estàs passant i la lectura a través de la línia d'exploració especial
i canviar segons sigui necessari i tot tipus de botiga dels píxels en una matriu.
Després, més tard vostè sap que vostè haurà d'imprimir la matriu de nou,
i pel que només es pot utilitzar la matriu per fer això.
Una altra manera de fer-ho és que es podria copiar una fila cap avall,
Entenc que ha de copiar de nou, pel que en realitat mou el cursor,
i que utilitzarà el mètode fseek.
Vostè pot moure el cursor fins al final de nou i repeteixi el procés de còpia de nou.
>> Així que si el nostre nombre d'escala és n, llavors quantes vegades hem de tornar
i tornar a escriure una línia? >> [Estudiant] n - 1. >> Sí, perfecte. n - 1.
Ho hem fet ja una vegada, de manera que a continuació anem a voler repetir el procés de tornada enrere
n - 1 quantitat de vegades.
Bé. Així que aquí tenen la funció de canvi de mida.
>> Ara podem arribar a una part molt divertit, el meu favorit conjunt de processadors, que és Recover.
En lloc de mapes de bits, aquesta vegada estem tractant amb arxius JPEG.
Estem en realitat no dóna un sol arxiu d'imatges JPEG,
i quan ens donin bàsicament un format raw targeta de memòria.
I pel que aquest conté una mica d'informació de valors i les escombraries al principi,
i després comença i té un munt d'arxius JPEG.
No obstant això, ens va lliurar una targeta en la qual ha esborrat les fotos;
en essència, ens hem oblidat d'on les fotos es troben dins de la targeta.
Així que la nostra tasca de recuperar és anar a través d'aquest format de targeta
i trobar aquestes fotos una altra vegada.
>> Per sort, l'estructura d'arxius JPEG i l'arxiu de la targeta és una mica d'ajuda.
Que sens dubte podria haver estat una mica més complicat si no fos en aquest format en particular.
Cada arxiu JPEG en realitat comença amb dues seqüències possibles, enumerats anteriorment.
Bàsicament, cada vegada que tingui un nou arxiu JPEG,
que comença amb la seqüència de qualsevol ffd8 FFE0 ol'altre, ffd8 ffe1.
Una altra cosa útil és saber que els arxius JPEG s'emmagatzemen de forma contigua.
Així que cada vegada que un arxiu JPEG acaba, l'altre comença.
Així que no hi ha cap tipus d'en-entre els valors d'aquest país.
Quan arribi l'inici d'un arxiu JPEG, si ja has estat llegint un arxiu JPEG,
saps que has arribat al final de l'anterior i el començament de la següent.
>> Per tipus de visualitzar això, vaig fer un esquema.
Una altra cosa sobre els arxius JPEG és que podem llegir en les seqüències de 512 bytes al mateix temps,
de manera similar amb el començament de la targeta.
No necessitem estar comprovant cada byte únic, ja que seria un fàstic.
Així que en comptes, el que podem fer és en realitat acabo de llegir en 512 bytes alhora
i llavors, en lloc de comprovar entre els d'aquestes porcions diminutes,
només podem comprovar l'inici dels 512 bytes.
Essencialment, en aquesta imatge, el que es veu és en el començament de la targeta,
ha valors que no són realment rellevants per als arxius JPEG en si mateixes.
Però llavors el que tenim és un estel per indicar una de les dues seqüències de partida per a un JPEG.
Així que cada vegada que vegi un estel, vostè sap que té un arxiu JPEG.
I llavors tots els arxius JPEG serà un múltiple de 512 bytes
però no necessàriament el mateix múltiple.
La manera com vostè sap que vostè ha colpejat una altra JPEG és si es colpeja una altra estrella,
altra seqüència de partida de bytes.
Llavors, el que tenim aquí és que tingui l'arxiu JPEG vermell continua fins arribar a una estrella,
que s'indica mitjançant un color nou.
Vostè continua i llavors va colpejar una altra estrella, que va xocar amb un altre format JPEG,
continua tot el camí fins al final.
Ets a l'última foto aquí, el rosa.
Veu fins al final fins arribar a la final del personatge arxiu.
Això serà realment útil.
>> A pocs robatoris de pilota principals aquí:
L'arxiu de la targeta no s'inicia amb un arxiu JPEG,
però una vegada que comença un JPEG, tots els arxius JPEG s'emmagatzemen costat a costat entre si.
>> Alguns pseudocodi per a la Recuperació.
En primer lloc, anem a obrir el nostre arxiu de targeta,
i que estarà usant nostre arxiu d'E / S funcions.
Anem a repetir el procés fins que hem arribat al final del fitxer.
Anem a llegir 512 bytes alhora.
I el que vull dir aquí és que anem a guardar-lo en un buffer,
així que bàsicament s'aferren a aquests 512 bytes fins que sapiguem exactament què fer amb ells.
Llavors el que vull fer és que volem comprovar si ens hem topat amb un estel o no.
Si ens hem topat amb un estel, si hem colpejat una de les seqüències d'arrencada,
llavors sabem que hem assolit un nou arxiu JPEG.
El que vostè voldrà fer és que anem a voler crear un nou arxiu en el nostre directori pset4
per seguir fent aquest arxiu.
Però també, si ja hem fet un JPEG abans,
llavors volem acabar amb aquest arxiu i empènyer a la carpeta pset4,
on tindrem aquest arxiu guardat perquè si no s'especifica que hem acabat aquest arxiu JPEG,
a continuació, que bàsicament tindràs una quantitat indeterminada. Els arxius JPEG no tindrà fi.
Així que volem assegurar-nos que quan estem llegint en un arxiu JPEG i escrit que,
que es vol tancar específicament que, per obrir el següent.
Haurem de desitgi comprovar diverses coses.
Volem comprovar si estem en el començament d'una nova JPEG amb el nostre buffer
i també si ja ha trobat un JPEG abans
perquè això canviarà el seu procés lleugerament.
Així que després de passar per tot el camí i li va colpejar el final de l'arxiu,
llavors el que vostè voldrà fer és que vostè vol tancar tots els arxius que estiguin oberts.
Això probablement serà l'últim arxiu JPEG que vostè té,
així com l'arxiu de targetes que vostè ha estat tractant.
>> L'últim obstacle que hem d'abordar és com fer un arxiu JPEG
i com en realitat l'empeny a la carpeta.
El conjunt de processadors requereix que cada JPEG que es troba estar en el següent format,
on tens el nombre. jpg.
El nombre, fins i tot si és 0, l'anomenem 000.jpg.
Cada vegada que hi hagi un fitxer JPEG al programa,
vostè va a voler donar-li un nom en l'ordre en què es trobi.
Què vol dir això?
Hem de tipus de seguiment de quants hem trobat
i el que el nombre de cada JPEG ha de ser.
Aquí aprofitarem la funció sprintf.
Igual que printf, que només tipus d'impressions en un valor fora de la terminal,
sprintf imprimeix el fitxer a la carpeta de sortida.
I així el que això faria si tingués sprintf, títol, i després la cadena allà,
seria imprimir 2.jpg.
Suposant que he tancat els meus arxius correctament,
que conté l'arxiu que havia estat escrivint.
Però una cosa és que el codi que tinc aquí
no acaba de satisfer el que el conjunt de processadors requereix.
El conjunt de processadors requereix que el segon arxiu JPEG ha de ser nomenat 002 en comptes de 2.
Així que quan s'imprimeixi el nom, llavors potser vostè pot ser que vulgueu modificar lleugerament el marcador de posició.
>> Algú recorda com permetre espais addicionals quan escrivim alguna cosa?
Si. >> [Estudiant] Es posa un 3 per cent entre el signe i el 2. >> Sí, perfecte.
Vas a posar un 3 en aquest cas perquè volem que l'espai per a 3.
3d% probablement li donaria 002.jpg lloc de 2.
El primer argument en la funció sprintf és en realitat una matriu de caràcters,
que prèviament sabia com cadenes.
Aquells voluntat, una mica més com un dipòsit temporal, només emmagatzemar la cadena resultant.
En realitat, no es tracta d'això, sinó que cal incloure.
>> Sabent que cada nom de fitxer té el nombre, que ocupa tres personatges,
i llavors. jpg, quant de temps ha de ser aquesta matriu?
Llenci a les escombraries un nombre. Quants caràcters al títol, en el nom?
Així que hi ha tres hashtags, període, jpg. >> [Estudiant] 7. >> 7. No del tot.
Anem a voler 8 perquè volem permetre el terminador nul també.
>> Finalment, només per allargar el procés que es farà per recuperar,
vostè té alguna informació començament.
Continuar fins a trobar l'inici d'un arxiu JPEG,
i que pot ser o bé una de les dues seqüències de partida.
Tu segueix llegint. Cada barra representa aquí 512 bytes.
Vostè segueixi llegint, seguiu llegint fins que es troba amb una altra seqüència d'arrencada.
Un cop aconseguit això, s'acaba l'actual JPEG - en aquest cas, és el vermell,
per la qual cosa vol posar fi a això.
Vols sprintf el nom d'aquesta carpeta en el seu pset4,
llavors vostè vol obrir una nova JPEG i després seguir llegint
fins que es troba amb el següent.
Segueix llegint, segueix llegint,
i, finalment, amb el temps, has d'arribar al final de l'arxiu,
i pel que vostè vol tancar l'última JPEG que estaves treballant,
sprintf que a la seva carpeta pset4, i després veure totes les fotos que has aconseguit.
Aquestes fotos són en realitat imatges de CS50 personal,
i aquí és on ve la part divertida bonificació del conjunt de processadors es presenta en
és que estan competint en les seves seccions per trobar la TFS a les fotos
i prendre fotos amb ells per provar que vostè ha fet el conjunt de processadors
i perquè pugui veure que els membres del personal estan a les fotos.
Així que pren imatges amb el personal. De vegades hauràs de perseguir.
Probablement alguns d'ells tractarà de fugir de tu.
Es pren fotos amb ells.
Això està en curs. No és exigible quan el conjunt de processadors cal.
El termini es donaran a conèixer en l'especificació.
Llavors, amb la seva secció, el que porta a la majoria de la secció fotos
amb els membres de la majoria del personal es portaran un premi bastant impressionant.
Això és una mena d'incentiu per obtenir el seu pset4 acabi com més aviat millor
perquè llavors vostè pot anar per feina
la caça de tots els diferents membres del personal CS50.
Això no és obligatòria, però, així una vegada que les fotos,
llavors ja ha acabat amb pset4.
>> I he acabat amb Tutorial 4, així que gràcies a tots per venir.
Bona sort amb Forense. [Aplaudiment]
[CS50.TV]