Aus Datei lesen

Zusatz:

Zunächst kommt der so genannte Header der Datei, der eine
Menge an anderen Informationen enthält (um die wir uns NICHT kümmern)
und auch eine variable Größe besitzt. Danach kommt an einer bestimmten Stelle
die Information, dass nun die Bilddaten kommen. Diese Information ndet sich
dadurch, dass man die Daten (als short!) einliest und wenn die hexadezimale Zahlenkombination
(0x7FE0,0x0010) gefunden wird, müssen noch vier char-Daten
übersprungen werden, dann kommt als long die Anzahl der Bildpunkte und dann
beginnen die Bilddaten (nachzulesen im DICOM-Standard). Die Größe der Bilder
ist (bei der Computertomographie) 512 x 512 und die Bilddaten sind als short-
Variablen gespeichert. Die Skala der möglichen Daten in der Datei beträgt also
0 bis 4095. Diese Werte sind nicht direkt die CT-Werte: CT-Werte reichen von -
1024 HU bis +3071 HU, von den Werten in der Datei müssen also 1024 abgezogen
werden, um die tatsächlichen CT-Werte zu erhalten.

lg Zermy

Der Index beim Array zählt schon um die richtige Anzahl Bytes weiter.

char byte[20];
short word[10];
int i;

for (i=0;i<10;i++)
  printf("Adresse von byte[%d]: %p und word[%d]: %p\n", i, &byte[i], i, &word[i]);

Kannst du da sehen: http://codepad.org/9500XQz4
Du siehst, das die Adresse von byte immer um 1 weitergeht, die Adresse von word dagegen um 2.

Beispiel Hausnummern: rechts gerade, links ungerade. Du gehst auf der rechten Seite und sollst 4 Nummern weitergehen (von der 40 zur 44). Dann musst du doch nur 2 Häuser weiter (erst 42 dann 44).

Darum musst du durch die größe deines Feldtyps teilen.

Das ganze gilt auch dann, wenn du mit Pointern arbeitest. Der Compiler weiss dass du einen Zeiger auf short hast und rechnet entsprechend um.

Ah ok, danke für das Beispiel.

Das mit den Hausnummer ist ein guter Vergleich.

Ich sitze im Moment daran nun zu filtern... ich muss doch jetzt von den short werten erstmal 1024 abziehen damit ich dann meine werte hab die ich filtern kann.

aber lSize ist ja nicht die anzahl der short zeigen sonder aller oder?

Wenn ich das richtig sehe, ist lSize die Dateigröße in Byte mit mit Header und noch anderen Informationen.

Du hast 512*512 short.

bild = bild+i;  // Bild zeigt jetzt auf die eigentlichen Bilddaten
//Und dann
for(i=0;<i<512*512;i++)
{
  bild[i] = was du willst;
}

Ok das Bild sieht schonmal anders aus, aber falsch xD die rechte seite ist sozusagen links angehängt. Der Compiler sagt ich überschreite meinen Speicher.
Die while schleife ist für die Dateiausgabe. Das er es umspeichert.

Was ich wohl noch gar nicht durchblickt habe ist das durchsuchen im Speicher.
Ich meine in den short Werten sind doch meine CT-Werte gespeichert oder verstehe ich das falsch und ich muss doch 1024 short werde abziehen damit ich die richtige Anzahl von Werten habe.Ich will den wert von i auf 0 setzen wenn der zeiger an der richtigen Stelle ist. Aber das mit der Zeiger Programmierung ist ein riesen Thema, das muss ich noch oft lesen und viel rumprobieren...

bild = (short *)buffer; 
  for(i=0; i < (lSize / sizeof(short)-1); i++)
  if ((bild[i] == suchwerte[0]) && (bild[i+1] == suchwerte[1])  ) break;

  i+=(4/sizeof(short));

	lSize=result-sizeof(short)*(1024/4);
  printf("Filesize:%ld \n",lSize);

  for(x=0;x<lSize;x++)
  if(i =-900 || i>250)
  {
	  i=0;

  }

      }

      while(!feof(pFile)) {

          ch = fgetc(pFile);

          fputc(ch, output);

      }

Die 1024 haben etwas mit dem Wert des Bildpunktes zu tun, nicht mit dem Index.

hmm, ist echt schwer alles nachzuvollziehen, wenn grade die Zeiger und die Arrays nicht so klar sind.

Das Bild ist doch im Speicher und du hast mich an die richtige Stelle im Speicher gelenkt. Nun muss ich doch nur short für short auslesen und den Wert - 1024 rechnen? So versteh ich das und dann vergleichen ob der Wert größer oder kleiner ist.

lg Zermy

Zermy schrieb:

Das Bild ist doch im Speicher und du hast mich an die richtige Stelle im Speicher gelenkt. Nun muss ich doch nur short für short auslesen und den Wert - 1024 rechnen? So versteh ich das und dann vergleichen ob der Wert größer oder kleiner ist.

Richtig, nur hat dein Codebeispiel von 15:14 Uhr damit nichts zu tun.

Bei bild[i] steht ein Wert von dem Bild.

short pixel;

 pixel = bild[i] - 1024; // dann steht in pixel der geändert Wert.

Ok, sorry der code klemmt sehr bei mir.

Und die einzelnen Pixel vergleiche ich nun mit fgetc?

lg Zermy

Wieso kommt denn jetzt fgetc ins Spiel? Was soll das denn einlesen?

Vorhin hast du irgendetwas von "x<-900HU(Luft) oder x>250HU(Knochen) " geschrieben.
Ich nehme an das sollen deine Grenzwerte sein. Damit musst du rechnen.

Da in Pixel jetzt mein geänderter wert steht muss ich Pixel auf <-900 || >250 prüfen, wenn ein der fall ist auf 0 setzen. Wenn das nicht der Fall ist weiter machen.

Sehe ich das richtig? Und das wäre dann ne IF Anweisung oder?

lg Zermy

Ja.

Aber das zurückschreiben in das Array nicht vergessen.

Man kann das Ganze dann aber noch zusammenfassen.

Das Programm läuft zwar fehlerhaft, aber es kommt ein Bild mit ganz vielen weißen und schwarzen Punkten Naja eigentlich ist das nicht zum Lachen ...

short pixel;

 pixel = bild[i] - 1024;

// Das hast du mir ja vorgegeben, ab hier möchte ich dann gucken ob der wert in  Pixel größer oder kleiner ist und wenn das der Fall ist soll er in die If Anweisung gehen und pixel auf  -1024 also auf 0 im Datensatz setzen. 

 if( pixel<'-900'|| pixel>'250')
 {
	 pixel=-1024;
 }
 else
 {
	 bild[i+1];
// Ich will ja das er immer ein pixel weiter springt. Das heißt ich muss bild[i+1] nehmen damit er das nächste mal ein pixel weiter läuft
// wenn ich mich nicht irre muss ich noch eine For schleife bauen die das dann immer automatisch wiederholt oder denke ich total falsch?
 }

lg Zermy

Nein.

1. musst du in jedem Fall weiterzählen,
2. das weiteschalten macht doch die for-Schleife drum-herum (s. mein Post von 15:14 Uhr)
3. fehlt das bild[i] = pixel , wenn du pixel verändert hast.

Hmm, ich weiß grade echt nicht was ich falsch mache. Ich stehe an der stelle wo ich anfangen will zu lesen. Vergleiche das Pixel, wenn es ausgefiltert werden muss wirds auf -1024 gesetzt und in bild geschrieben, wenn das nicht der fall ist wir das Pixel einfach in bild geschrieben und i zählt einen hoch für das nächste Pixel.

bild = bild+i;

for(x=0;x<512*512;x++)
{
	short pixel;

	pixel = bild[i] - 1024;

	if( pixel<'-900'|| pixel>'250')
 {
	 pixel=-1024;

 }
        bild[i] = pixel;
	i++;
}

lg Zermy

Hier nochmal das ganze, macht aber nun das Bild kaputt!

Man kann es nicht mehr öffnen.

#include <stdio.h>
#include <stdlib.h>

int main () {
  FILE * pFile;
  long lSize;
  char * buffer;
  size_t result;
  int i,n=0,x,y,z,v=0;
  short c;
  short suchwerte[2] = {0x7FE0,0x0010};
  short *bild;
  FILE *output;
  int *b;
      int ch;

  pFile = fopen ( "C:\\Dokumente und Einstellungen\\XXXX\\Desktop\\Bilder\\Kopf.IMA" , "rb" );
  if (pFile==NULL) {fputs ("File error",stderr); exit (4);}

  output = fopen("C:\\Dokumente und Einstellungen\\XXXX\\Desktop\\Bilder\\Kopf_seg.ima","wb+");

      if(output == NULL) 

          {fputs ("File error",stderr); exit (4);}

  // Anzeige der Filegröße
  fseek (pFile , 0 , SEEK_END);
  lSize = ftell (pFile);
  rewind (pFile);

  printf("Filesize:%ld \n",lSize);

  // Belegung des Speicher für den kompletten File
  buffer = (char*) malloc (sizeof(char)*lSize);
  if (buffer == NULL) {fputs ("File error",stderr); exit (1);}

  // Kopieren des File in Speicher
  result = fread (buffer,1,lSize,pFile);
  if (result != lSize) {fputs ("File error",stderr); exit (2);}

  bild = (short *)buffer; 
  for(i=0; i < (lSize / sizeof(short)-1); i++)
  if ((bild[i] == suchwerte[0]) && (bild[i+1] == suchwerte[1])  ) break;

  i+=(4/sizeof(short));

  bild = bild+i;

for(x=0;x<512*512;x++)
{
	short pixel;

	pixel = bild[i] - 1024;

	if( pixel<'-900'|| pixel>'250')
 {
	 pixel=-1024;

 }
	bild[i] = pixel;
	i++;

} 

 while(!feof(pFile)) {

          ch = fgetc(pFile);

          fputc(ch, output);

      }

	system("PAUSE");

  /* Die Datei ist nun komplett im Speicher :) */

  // Schließen und speicher freigeben
  fclose (pFile);
  free (buffer);

  return 0;

    }

edit durch Seppj: Auf Wunsch des unregistrierten Nutzers versehentlich geposteten Realnamen zensiert.

bild = bild+i;  // ab hier zeigt bild wirklich auf deine Bilddaten.

for(x=0;x<512*512;x++)  // Welcher Typ ist denn x?
{
    short pixel;

    pixel = bild[i] - 1024; // Warum denn jetzt i? Welchen Wert hat i denn hier?

    if( pixel<'-900'|| pixel>'250')
    {
      pixel=-1024;

    }
    bild[i] = pixel;  // das brauchst du nur, wenn du pixel auch änderst. Dann musst du den Wertebereich auch wieder anpassen
    i++;
}

[/quote]

Wenn du bild = bild+i; schreibst, musst du danach auch i= 0; machen.
Oder lass beides weg.

Trotzdem wichtig: von welchem Typ ist i ?

i ist int.

i und x sind int.

Lass dir mal in Zeile 55 den Wert von i und von lSize ausgeben. Den Zusammenhang zwischen beiden kennst du ja (Hausnummern)

Welchen Wert hat i, wenn die Suchwerte nicht gefunden werden?
Zu Zeile 58 bis 74 habe ich schon etwas geschrieben.

Was soll Zeile 78 bis 84.
Du hast die Datei komplett in Zeile 41 eingelesen. Danach kann nur EOF kommen.
Außerdem musst du output auch wieder schließen.

Du must eigentlich nur buffer in output schreiben. (Was ist das Gegenteil von fread?)

Und nochmal:

Zermyy schrieb:

Die Skala der möglichen Daten in der Datei beträgt also
0 bis 4095. Diese Werte sind nicht direkt die CT-Werte: CT-Werte reichen von -
1024 HU bis +3071 HU, von den Werten in der Datei müssen also 1024 abgezogen
werden, um die tatsächlichen CT-Werte zu erhalten.

Wenn bei dir jetzt -1024 in den Daten steht, musst du das irgendwie wieder rückgangig machen.
Du musst dir etwas für die Zeile bild[i] = pixel; überlegen, wie du wieder auf 0 bis 4095 kommst.

Ich war noch am schreiben, darum kannte ich dein Post von 19:16 vorhin noch nicht. :p