udisplay.cpp

dicom file 查看工具 DICOM文件是医疗设备使用的文件格式。

  delete pStream;

  pCh=pBuffer;
  for(y=0;y<m_pImageInformation->nImageHeight;y++)
  {
    for(x=0;x<m_pImageInformation->nImageWidth;x++)
    {
      ColorR=pCh[x*3];
      ColorG=pCh[x*3+1];
      ColorB=pCh[x*3+2];
      m_pBitmap32->Pixel[x][y]=Color32(ColorR,ColorG,ColorB);
    }
    pCh+=m_pImageInformation->nImageWidth*3;
  }
  
  delete []pBuffer;
}
//---------------------------------------------------------------------------
/*
void __fastcall TfrmDisplay::DecompressRLE(void)
{
  char Ch;
  int nIndex=0;
  int nCount=0;
  int i;
  int nSize;

  nSize=m_pImageInformation->nImageWidth*m_pImageInformation->nImageHeight;

  nIndex=m_nRGBSegmentOffset[0];
  while(true)
  {
    Ch=m_pBackBuffer[nIndex];
    nIndex++;
    if(Ch>=0)
    {
      for(i=0;i<=Ch;i++)
      {
        m_pBuffer[nCount]=m_pBackBuffer[nIndex];
        nCount++;
        nIndex++;
      }
    }
    else if((Ch<=-1)&&(Ch>=-127))
    {
      for(i=0;i<=(-Ch);i++)
      {
        m_pBuffer[nCount]=m_pBackBuffer[nIndex];
        nCount++;
      }
      nIndex++;
    }
    if(nIndex>=m_pImageInformation->nImageSize || nCount>=nSize) break;
  }
} */
//---------------------------------------------------------------------------
void __fastcall TfrmDisplay::ReadRLEGray8(void)
{
  unsigned int x,y;
  char Bits;
  char *pCh;
  char *pBackBuffer;
  char *pBuffer;
  int nSize;
  TFileStream *pStream;
  int nIndex;
  int nCount;
  char Ch;
  int i;

  nSize=m_pImageInformation->nImageWidth*m_pImageInformation->nImageHeight;

  pBackBuffer=new char[nSize];
  pBuffer=new char[m_pImageInformation->nImageFileSize];

  pStream=new TFileStream(m_TempFileName,fmOpenRead);
  pStream->ReadBuffer(pBuffer,m_pImageInformation->nImageFileSize);
  delete pStream;

  m_nRGBSegmentOffset[0]=*(int *)(pBuffer+4);   

  nIndex=m_nRGBSegmentOffset[0];
  nCount=0;
  while(true)
  {
    Ch=pBuffer[nIndex];
    nIndex++;
    if(Ch>=0)
    {
      for(i=0;i<=Ch;i++)
      {
        pBackBuffer[nCount]=pBuffer[nIndex];
        nCount++;
        nIndex++;
      }
    }
    else if((Ch<=-1)&&(Ch>=-127))
    {
      for(i=0;i<=(-Ch);i++)
      {
        pBackBuffer[nCount]=pBuffer[nIndex];
        nCount++;
      }
      nIndex++;
    }
    if(nIndex>=m_pImageInformation->nImageFileSize || nCount>=nSize) break;
  }

  pCh=pBackBuffer;
  for(y=0;y<m_pImageInformation->nImageHeight;y++)
  {
    for(x=0;x<m_pImageInformation->nImageWidth;x++)
    {
      Bits=pCh[x];
      m_pBitmap32->Pixel[x][y]=Color32(Bits,Bits,Bits);
    }
    pCh+=m_pImageInformation->nImageWidth;
  }

  delete []pBackBuffer;
  delete []pBuffer;
}
//---------------------------------------------------------------------------
void __fastcall TfrmDisplay::ReadRLEGray16(void)
{
  //unsigned int x,y;
  //char Bits;
  //char *pCh;
  TFileStream *pStream;
  unsigned short int *pBit;
  //int nMax,nMin,nValue;
  int nSize;
  char *pBackBuffer,*pBuffer;
  char Ch;
  int nIndex=0;
  int nCount=0;
  int i;

  nSize=m_pImageInformation->nImageWidth*m_pImageInformation->nImageHeight;

  pBackBuffer=new char[nSize];
  pBuffer=new char[m_pImageInformation->nImageFileSize];

  pStream=new TFileStream(m_TempFileName,fmOpenRead);
  pStream->ReadBuffer(pBuffer,m_pImageInformation->nImageFileSize);
  delete pStream;

  m_nRGBSegmentOffset[0]=*(int *)(pBuffer+4);
  m_nRGBSegmentOffset[1]=*(int *)(pBuffer+8);

  nIndex=m_nRGBSegmentOffset[1];
  pBit=(unsigned short int *)m_pBuffer;
  while(true)
  {
    Ch=pBuffer[nIndex];
    nIndex++;
    if(Ch>=0)
    {
      for(i=0;i<=Ch;i++)
      {
        pBit[nCount]=pBuffer[nIndex];
        nCount++;
        nIndex++;
      }
    }
    else if((Ch<=-1)&&(Ch>=-127))
    {
      for(i=0;i<=(-Ch);i++)
      {
        pBit[nCount]=pBuffer[nIndex];
        nCount++;
      }
      nIndex++;
    }
    if(nIndex>=m_pImageInformation->nImageFileSize || nCount>=nSize) break;
  }

  for (nIndex=0;nIndex<nSize;nIndex++) pBit[nIndex]=(pBit[nIndex]>>1);
  
  nIndex=m_nRGBSegmentOffset[0];
  nCount=0;
  while(true)
  {
    Ch=pBuffer[nIndex];
    nIndex++;
    if(Ch>=0)
    {
      for(i=0;i<=Ch;i++)
      {
        pBit[nCount]+=((unsigned int)pBuffer[nIndex]<<7);
        nCount++;
        nIndex++;
      }
    }
    else if((Ch<=-1)&&(Ch>=-127))
    {
      for(i=0;i<=(-Ch);i++)
      {
        pBit[nCount]+=((unsigned int)pBuffer[nIndex]<<7);
        nCount++;
      }
      nIndex++;
    }
    if(nIndex>=m_pImageInformation->nImageFileSize || nCount>=nSize) break;
  }

  /*
  if (m_pImageInformation->nImageLargestPixel>32767)
  {
    for(i=0;i<nSize;i++)
    {
      if (pBit[i]>=0) pBit[i]-=32768;
      else pBit[i]+=32768;
    }
  }
  */
  /*
  nValue=pBit[0];
  nMax=nValue;
  nMin=nValue;

  for(i=0;i<nSize;i++)
  {
    nValue=pBit[i];
    if (nValue<nMin) nMin=nValue;
    if (nValue>nMax) nMax=nValue;
  }
  nValue=nMax-nMin;

  if (!nValue) nValue=1;
  for (i=0;i<nSize;i++) pBackBuffer[i]=255*(pBit[i]-nMin)/nValue;

  pCh=pBackBuffer;
  for(y=0;y<m_pImageInformation->nImageHeight;y++)
  {
    for(x=0;x<m_pImageInformation->nImageWidth;x++)
    {
      Bits=pCh[x];
      m_pBitmap32->Pixel[x][y]=Color32(Bits,Bits,Bits);
    }
    pCh+=m_pImageInformation->nImageWidth;
  }
  */
  delete []pBuffer;
  delete []pBackBuffer;
}
//---------------------------------------------------------------------------
void __fastcall TfrmDisplay::ReadRLEColor(void)
{
  unsigned int x,y;
  char Bits;
  char *pCh;
  char *pBackBuffer;
  char *pBuffer;
  int nSize;
  TFileStream *pStream;
  int nIndex;
  int nCount;
  int i;
  int nSegmentCount;
  char ColorR,ColorG,ColorB;
  char Ch;
  int nEndSize;
  
  nSize=m_pImageInformation->nImageWidth*m_pImageInformation->nImageHeight;

  pBackBuffer=new char[nSize*3];
  pBuffer=new char[m_pImageInformation->nImageFileSize];

  pStream=new TFileStream(m_TempFileName,fmOpenRead);
  pStream->ReadBuffer(pBuffer,m_pImageInformation->nImageFileSize);
  delete pStream;

  m_nRGBSegmentOffset[0]=*(int *)(pBuffer+4);    //1st Offset: RED
  m_nRGBSegmentOffset[1]=*(int *)(pBuffer+8);    //2nd Offset: GREEN, unused for monochrome
  m_nRGBSegmentOffset[2]=*(int *)(pBuffer+12);   //3rd Offset: BLUE, unused for monochrome

  nCount=0; 
  for (nSegmentCount=0;nSegmentCount<3;nSegmentCount++)
  {
    nEndSize=nSize*(nSegmentCount+1)-1;
    nIndex=m_nRGBSegmentOffset[nSegmentCount];
    while(true)
    {
      Ch=pBuffer[nIndex];
      nIndex++;
      if(Ch>=0)
      {
        for(i=0;i<=Ch;i++)
        {
          pBackBuffer[nCount]=pBuffer[nIndex];
          nCount++;
          nIndex++;
        }
      }
      else if((Ch<=-1)&&(Ch>=-127))
      {
        for(i=0;i<=(-Ch);i++)
        {
          pBackBuffer[nCount]=pBuffer[nIndex];
          nCount++;
        }
        nIndex++;
      }
      if(nIndex>=m_pImageInformation->nImageFileSize || nCount>nEndSize) break;
    }
  }

  pCh=pBackBuffer;
  for(y=0;y<m_pImageInformation->nImageHeight;y++)
  {
    for(x=0;x<m_pImageInformation->nImageWidth;x++)
    {
      ColorR=pCh[x];
      ColorG=pCh[x+nSize];
      ColorB=pCh[x+nSize+nSize];
      m_pBitmap32->Pixel[x][y]=Color32(ColorR,ColorG,ColorB);
    }
    pCh+=m_pImageInformation->nImageWidth;
  }

  if (pBackBuffer) delete []pBackBuffer;
  if (pBuffer) delete []pBuffer;
}
//---------------------------------------------------------------------------
void __fastcall TfrmDisplay::ReadJPEGLSColor(void)
{
  FILE *fp;
  char ColorR,ColorG,ColorB;
  unsigned int x,y;
  char *pCh;
  char *pBuffer;

  pBuffer=new char[m_pImageInformation->nImageWidth*m_pImageInformation->nImageHeight*3];

  fp=fopen(m_TempFileName.c_str(),"rb");
  JPEGLosslessDecodeImage(fp,(unsigned short *)pBuffer,24,m_pImageInformation->nImageFileSize);
  fclose(fp);

  pCh=pBuffer;
  for(y=0;y<m_pImageInformation->nImageHeight;y++)
  {
    for(x=0;x<m_pImageInformation->nImageWidth;x++)
    {
      ColorR=pCh[x*3];
      ColorG=pCh[x*3+1];
      ColorB=pCh[x*3+2];
      m_pBitmap32->Pixel[x][y]=Color32(ColorR,ColorG,ColorB);
    }
    pCh+=m_pImageInformation->nImageWidth*3;
  }

  delete []pBuffer;
}
//---------------------------------------------------------------------------
void __fastcall TfrmDisplay::ReadJPEGLSGray8(void)
{
  FILE *fp;
  char ColorR,ColorG,ColorB;
  unsigned int x,y;
  char *pCh;
  char *pBuffer;
  char Bits;

  pBuffer=new char[m_pImageInformation->nImageWidth*m_pImageInformation->nImageHeight];

  fp=fopen(m_TempFileName.c_str(),"rb");
  JPEGLosslessDecodeImage(fp,(unsigned short *)pBuffer,8,m_pImageInformation->nImageFileSize);
  fclose(fp);

  pCh=pBuffer;
  for(y=0;y<m_pImageInformation->nImageHeight;y++)
  {
    for(x=0;x<m_pImageInformation->nImageWidth;x++)
    {
      Bits=pCh[x];
      m_pBitmap32->Pixel[x][y]=Color32(Bits,Bits,Bits);
    }
    pCh+=m_pImageInformation->nImageWidth;
  }

  delete []pBuffer;
}
//---------------------------------------------------------------------------
void __fastcall TfrmDisplay::ReadJPEGLSGray16(void)
{
  FILE *fp;
  unsigned short *pBit;
  int nSize;
  int i;

  nSize=m_pImageInformation->nImageWidth*m_pImageInformation->nImageHeight;

  fp=fopen(m_TempFileName.c_str(),"rb");
  JPEGLosslessDecodeImage(fp,(unsigned short *)m_pBuffer,16,m_pImageInformation->nImageFileSize);
  fclose(fp);

  pBit=(unsigned short *)m_pBuffer;
  if (m_pImageInformation->nImageLargestPixel>32767)
  {
    for(i=0;i<nSize;i++)
    {
      if (pBit[i]>=0) pBit[i]-=32768;
      else pBit[i]+=32768;
    }
  }
}
//---------------------------------------------------------------------------
inline int __fastcall TfrmDisplay::RescaleFromBuffer(int nItem)
{
  return (int)(nItem*m_pImageInformation->fRescaleSlope+m_pImageInformation->fRescaleIntercept);
}
//---------------------------------------------------------------------------
inline int __fastcall TfrmDisplay::RescaleToBuffer(int nItem)
{
  return (int)((nItem-m_pImageInformation->fRescaleIntercept)/m_pImageInformation->fRescaleSlope);
}
//---------------------------------------------------------------------------
void __fastcall TfrmDisplay::ImgView32MouseMove(TObject *Sender,
      TShiftState Shift, int X, int Y, TCustomLayer *Layer)
{
  if (m_bIsMouseDrag)
  {
    ImgView32->Scroll(m_OldMousePos.x-X,m_OldMousePos.y-Y);
    m_OldMousePos=Gr32::Point(X, Y);
    ImgView32->Update();
  }
}
//---------------------------------------------------------------------------

void __fastcall TfrmDisplay::ImgView32MouseDown(TObject *Sender,
      TMouseButton Button, TShiftState Shift, int X, int Y,
      TCustomLayer *Layer)
{
  if (Button==mbLeft)
  {
    m_OldMousePos=Gr32::Point(X,Y);
    m_bIsMouseDrag=true;
    ImgView32->Cursor=crHandPoint;
  }
  else ReleaseCapture();
}
//---------------------------------------------------------------------------

void __fastcall TfrmDisplay::ImgView32MouseUp(TObject *Sender,
      TMouseButton Button, TShiftState Shift, int X, int Y,
      TCustomLayer *Layer)
{
  if (Button==mbLeft)
  {
    m_bIsMouseDrag=false;
    ImgView32->Cursor=crDefault;
  }
}
//---------------------------------------------------------------------------
void __fastcall TfrmDisplay::SaveAsColor(AnsiString FileName,FREE_IMAGE_FORMAT nFileType)
{
  FIBITMAP *pBitmap;
  RGBTRIPLE *pBits;
  int x,y;
  unsigned char cR,cG,cB;

  pBitmap=FreeImage_Allocate(ImgView32->Bitmap->Width,
                             ImgView32->Bitmap->Height,
                             24);
  if (pBitmap)    // bitmap successfully created!
  {
    pBits=(RGBTRIPLE *)FreeImage_GetBits(pBitmap);
    for (y=ImgView32->Bitmap->Height-1;y>=0;y--)
        for (x=ImgView32->Bitmap->Width-1;x>=0;x--)
        {
          Color32ToRGB(ImgView32->Bitmap->Pixel[x][y],cR,cG,cB);
          pBits->rgbtRed=cR;
          pBits->rgbtGreen=cG;
          pBits->rgbtBlue=cB;
          pBits++;
        }

    FreeImage_Save(nFileType,pBitmap,FileName.c_str(), 0);
    FreeImage_Unload(pBitmap);
  }
}
//---------------------------------------------------------------------------
void __fastcall TfrmDisplay::SaveAsGray(AnsiString FileName,FREE_IMAGE_FORMAT nFileType)
{
  FIBITMAP *pBitmap;
  BYTE *pBits;
  int x,y;
  unsigned char cR,cG,cB;
  int i;
  RGBQUAD *pPalette;

  pBitmap=FreeImage_Allocate(ImgView32->Bitmap->Width,
                             ImgView32->Bitmap->Height,
                             8);
  if (pBitmap)    // bitmap successfully created!
  {
    pPalette=FreeImage_GetPalette(pBitmap);
    for (i=0;i<256;i++)
    {
      pPalette[i].rgbRed=i;
      pPalette[i].rgbGreen=i;
      pPalette[i].rgbBlue=i;
    }

    pBits=(BYTE *)FreeImage_GetBits(pBitmap);
    for (y=ImgView32->Bitmap->Height-1;y>=0;y--)
        for (x=ImgView32->Bitmap->Width-1;x>=0;x--)
        {
          Color32ToRGB(ImgView32->Bitmap->Pixel[x][y],cR,cG,cB);
          *pBits=cR;
          pBits++;
        }

    FreeImage_Save(nFileType,pBitmap,FileName.c_str(), 0);
    FreeImage_Unload(pBitmap);
  }
}
//---------------------------------------------------------------------------