label.cpp

图像处理软件,功能比较基础

#include <stdafx.h>
#include <stdio.h>
#include <stdlib.h>
#include <process.h>
#include <math.h>

#include "common.h"
#include "basic.h"
#include "label.h"

/**********************  GETNEIGHBORTABLE  **************************/
/* Find every subblock and the relations between them */
unsigned GetNeighborTable(unsigned char **array, int RowLen, int ColLen,
                          unsigned **neighbor, unsigned **TemArray,
                          unsigned *TabLen, unsigned *area)
{
  unsigned  GrayNo;
  int       StartPos, EndPos, GrayNoLastLine, *Gray;
  int       i, j, k;

  Gray = (int *)fspace_1d(MAXSLINK,sizeof(int));

  GrayNo  = 0;
  *TabLen = 0;

  for (i=0; i<RowLen; i++)           //
    for (j=0; j<ColLen; j++)         //
      if (array[i][j])
      {
        StartPos = j;
        do                           //
        {                            //
          j++;                       //
          if (j==ColLen)  break;     //
        } while (array[i][j]);       //
        EndPos = j-1;

        GrayNoLastLine = 0;
        for (k=StartPos-1; k<=EndPos+1; k++)
        {
          if (i-1<0)  break;                  //  For the first line
          if ((k<0)||(k>=ColLen))  continue;  //
          if (TemArray[i-1][k])
          {
            if (GrayNoLastLine>=MAXSLINK) return -1;
            Gray[GrayNoLastLine] = TemArray[i-1][k];
            GrayNoLastLine++;
            while (TemArray[i-1][k]) k++;
          }
        }

        if (GrayNoLastLine==0)
        {
          GrayNo++;
          if (GrayNo>MAXSUBBLOCK) return -1;
          if (*TabLen>=MAXLINK) return -1;
          neighbor[0][*TabLen] = GrayNo;
          neighbor[1][*TabLen] = GrayNo;
          (*TabLen)++;
          area[GrayNo] = EndPos - StartPos + 1;
          for (k=StartPos; k<=EndPos; k++)
            TemArray[i][k] = GrayNo;
        }
        else
        {
          for (k=StartPos; k<=EndPos; k++)
            TemArray[i][k] = Gray[0];
          area[Gray[0]] += EndPos - StartPos + 1;
          for (k=1; k<GrayNoLastLine; k++)
          {
            if (*TabLen>=MAXLINK) return -1;
            neighbor[0][*TabLen] = Gray[0];
            neighbor[1][*TabLen] = Gray[k];
            (*TabLen)++;
          }
        }
      }


  free(Gray);

  return(GrayNo);
}

/**********************  GETMAPTABLE  ****************************/
/*
   From all subblocks and the relations between them to find the true
     blocks
*/
unsigned GetMapTable(unsigned **neighbor, unsigned TabLen, unsigned *map)
{
  unsigned  *stack, i, j, TrueObj, StackPtr, TmpValue;

  stack = (unsigned *)fspace_1d(MAXSLINK,sizeof(unsigned));

  TrueObj  = 0;
  StackPtr = 0;

  for (i=0; i<TabLen; i++)
  {
    if (neighbor[0][i])
    {
      stack[StackPtr] = neighbor[0][i];
      StackPtr++;
      TrueObj++;
      neighbor[0][i] = 0;
      neighbor[1][i] = 0;
    }

    while (StackPtr)
    {
      StackPtr--;
      TmpValue = stack[StackPtr];
      map[TmpValue] = TrueObj;

      for (j=i; j<TabLen; j++)
        if ((neighbor[0][j] == TmpValue) || (neighbor[1][j] == TmpValue))
        {
          if (neighbor[0][j]!=neighbor[1][j])
          {
            stack[StackPtr] = (neighbor[0][j]!=TmpValue)?neighbor[0][j]
                                                        :neighbor[1][j];
            StackPtr++;
          }
          neighbor[0][j] = 0;
          neighbor[1][j] = 0;
        }
    }
  }

  free(stack);

  return(TrueObj);
}

/************************  MODIFYMAPTABLE1  ***************************/
/* Use the Minarea to find the true objects */
int ModifyMapTable1(unsigned *map, unsigned *area, unsigned GrayNo,
                    unsigned TrueObj, int MinArea)
{
  int TrueTrueObj;
  unsigned i, j;
  unsigned TmpArea;

  TrueTrueObj = 0;
  for (i=1; i<=TrueObj; i++)
  {
    TmpArea = 0;

    for (j=1; j<=GrayNo; j++)
      if (map[j]==i)
        TmpArea += area[j];

    if (TmpArea<(unsigned)MinArea)
    {
      for (j=1; j<=GrayNo; j++)
        if (map[j]==i)
          map[j] = 0;
    }
    else
    {
      TrueTrueObj++;
      if (TrueTrueObj>MAXBLOCK)
      {
        printf("  Blocks are too many!\n");
        exit(1);
      }
      for (j=1; j<=GrayNo; j++)
        if (map[j]==i)
          map[j] = TrueTrueObj;
    }
  }

  return(TrueTrueObj);
}

/************************  MODIFYMAPTABLE2  ***************************/
/* Let the max block to be the true objects */
void ModifyMapTable2(unsigned *map, unsigned *area, unsigned GrayNo,
                     unsigned TrueObj)
{
  int MaxBlockNo;
  unsigned i, j;
  unsigned MaxBlockArea,*TmpArea;
  long Tmp = 0;

  TmpArea = (unsigned *)fspace_1d(MAXBLOCK+1,sizeof(unsigned));

  /* Get the area of all blocks */
  for (i=1; i<=TrueObj; i++)
  {
    TmpArea[i] = 0;

    for (j=1; j<=GrayNo; j++)
      if (map[j]==i)
        TmpArea[i] += area[j];

    Tmp +=  TmpArea[i];

  }

  /* Find the block number of the max block */
  MaxBlockArea = 0;
  for (i=1;i<=TrueObj;i++)
    if (TmpArea[i]>MaxBlockArea)
    {
      MaxBlockArea = TmpArea[i];
      MaxBlockNo = i;
    }

  for (i=1;i<=GrayNo;i++)
    if (map[i]!=(unsigned)MaxBlockNo)
      map[i] = 0;
    else
      map[i] = 1;

  free(TmpArea);
}

/***************************  DOMAP  *****************************/
/* Label the true objects */
void DoMap(unsigned char **array, unsigned **TemArray, int RowLen, int ColLen,
           unsigned *map)
{
  int i, j;

  map[0] = 0;
  for (i=0; i<RowLen; i++)    //
    for (j=0; j<ColLen; j++)  //
      if (map[TemArray[i][j]])
        array[i][j] = MAXGRAYLEVEL - map[TemArray[i][j]] + 1;
      else
        array[i][j] = 0;
}

/****************************  LABEL  ****************************/
int Label(unsigned char **array,int RowLen, int ColLen,int LabelMode,
          int MinArea)
          /*  LabelMode = LABELMODE_1, Use the Minarea to find the true objects */
          /*  LabelMode = LABELMODE_2, Let the max block to be the true objects */
          /*  MinArea is only used when LabelMode is LABELMODE_1                */
{
  unsigned  *map, *TmpArea, **neighbor, **TemArray, TabLen, GrayNo, TrueObj;
  int       i, j;

  map      = (unsigned *)fspace_1d(MAXSUBBLOCK+1,sizeof(unsigned));
  TmpArea  = (unsigned *)fspace_1d(MAXSUBBLOCK+1,sizeof(unsigned));
  neighbor = (unsigned **)fspace_2d(2,MAXLINK,sizeof(unsigned));
  TemArray = (unsigned **)fspace_2d(RowLen,ColLen,sizeof(unsigned));

  GrayNo = GetNeighborTable(array, RowLen, ColLen, neighbor, TemArray, &TabLen,
                            TmpArea);

  if (GrayNo>MAXSUBBLOCK) return -1;
  
  if (GrayNo==0)
  {
    for(i=0;i<RowLen;i++)
      for(j=0;j<ColLen;j++)
        array[i][j] = 0;

    free(map);
    free(TmpArea);
    ffree_2d((void **)neighbor,2);
    ffree_2d((void **)TemArray,RowLen);

    return(0);
  }

  TrueObj = GetMapTable(neighbor, TabLen, map);

  if (LabelMode==1)
  {
    TrueObj = ModifyMapTable1(map, TmpArea, GrayNo, TrueObj, MinArea);
  }
  else
  {
    ModifyMapTable2(map, TmpArea, GrayNo, TrueObj);
    TrueObj = 1;
  }

  DoMap(array, TemArray, RowLen, ColLen, map);

  free(map);
  free(TmpArea);
  ffree_2d((void **)neighbor,2);
  ffree_2d((void **)TemArray,RowLen);

  return(TrueObj);
}