Ignore:
Timestamp:
07/15/03 15:05:21 (21 years ago)
Author:
tbretz
Message:
*** empty log message ***
Location:
trunk/MagicSoft/Cosy/videodev
Files:
4 added
9 edited

Legend:

Unmodified
Added
Removed

  • trunk/MagicSoft/Cosy/videodev/Camera.cc

    r1802 r2278  
    4747void Camera::SigInit()
    4848{
     49    return;
    4950    struct sigaction act, old;
    5051
    … …  
    215216    while (img < end)
    216217    {
    217         *beg = *img;
    218 
     218        *beg++ = *img;
    219219        img += depth;
    220         beg++;
    221220    }
    222221}

  • trunk/MagicSoft/Cosy/videodev/Camera.h

    r1802 r2278  
    1414#endif
    1515
     16#include "PixGetter.h"
    1617#include "PixClient.h"
    1718
    18 class Camera
     19class Camera : public PixGetter
    1920{
    2021private:

  • trunk/MagicSoft/Cosy/videodev/CaosFilter.cc

    r1810 r2278  
    2828}
    2929
    30 float CaosFilter::Mean(const byte *buffer, const int offset, int *min, int *max)
    31 {
    32     double mean = 0.0;
    33 
    34     *min = 0xff;
    35     *max = 0x00;
     30void CaosFilter::GetStat(const byte *buffer, const int offset, double *mean, double *sdev)
     31{
     32    double sum = 0;
     33    double sq  = 0;
     34
     35    byte *s  = (byte*)buffer;
     36    const byte *e0 = s+768*576;
    3637
    3738    //
    3839    // calculate mean value
    3940    //
    40     for (int x=offset; x<768-offset; x++)
    41         for (int y=offset; y<576-offset; y++)
    42         {
    43             byte val = buffer[y*768+x];
    44 
    45             mean += val;
    46 
    47             if (val>*max)
    48                 *max = val;
    49 
    50             if (val<*min)
    51                 *min = val;
    52         }
    53 
    54     mean /= (768-2*offset)*(576-2*offset);
    55 
    56     return mean;
     41    while (s<e0)
     42    {
     43        const byte *e = s+576-offset;
     44        s += offset;
     45
     46        while (s<e)
     47        {
     48            sum += *s;
     49            sq  += *s * *s;
     50            s++;
     51        }
     52
     53        s+=offset;
     54    }
     55
     56    const Int_t sz = (768-2*offset)*(576-2*offset);
     57
     58    sum /= sz;
     59    sq  /= sz;
     60
     61    *mean = sum;
     62    *sdev = sqrt(sq-sum*sum);
    5763}
    5864
    … …  
    8086    return (int)my*768 + (int)mx;
    8187}
    82 
    83 float CaosFilter::SDev(const byte *buffer, const int offset, const double mean)
    84 {
    85     //
    86     // calculate sigma
    87     //
    88     double sdev=0.0;
    89 
    90     for (int x=offset; x<768-offset; x++)
    91         for (int y=offset; y<576-offset; y++)
    92         {
    93             const float val = mean - buffer[y*768+x];
    94 
    95             sdev += val*val;
    96         }
    97 
    98     sdev /= (768-2*offset)*(576-2*offset)-1;
    99 
    100     return sqrt(sdev);
    101 }
    102 
    10388
    10489int CaosFilter::GetMeanPosition(const byte *bitmap, const int x, const int y,
    … …  
    389374    const int offset = 10;
    390375
    391     int max;
    392     int min;
    393 
    394     const float mean = Mean(img, offset, &min, &max);
    395     const float sdev = SDev(img, offset, mean);
    396 
    397     const float cut = mean + 2.5*sdev;
     376    double mean, sdev;
     377    GetStat(img, offset, &mean, &sdev);
     378
     379    const byte max = mean+2.5*sdev>254 ? 254 : (byte)(mean+2.5*sdev);
    398380
    399381    //
    400382    // clean image from noise
    401383    //
    402     for (int x=0; x<768; x++)
    403         for (int y=0; y<576; y++)
    404         {
    405             if (img[y*768+x]>cut)
    406                 continue;
    407 
    408             //
    409             // FIXME: Create LOOKUP Table!
    410             //
    411 
    412             img[y*768+x] = 0;
    413         }
     384    const byte *e = img+768*576;
     385    byte *i = img;
     386    while (i<e)
     387    {
     388        if (*i<=max)
     389            *i = 0;
     390        i++;
     391    }
    414392
    415393    //
    … …  
    511489    const int offset = 10;
    512490
    513     int max;
    514     int min;
    515 
    516     const float mean = Mean(img, offset, &min, &max);
    517     const float sdev = SDev(img, offset, mean);
    518 
    519     const float cut = mean + 2.5*sdev;
     491    double mean, sdev;
     492    GetStat(img, offset, &mean, &sdev);
     493
     494    const byte cut = mean+2.5*sdev>254 ? 254 : (byte)(mean + 2.5*sdev);
    520495
    521496    //
    522497    // clean image from noise
    523498    //
    524     for (int x=0; x<768; x++)
    525         for (int y=0; y<576; y++)
    526         {
    527             if (img[y*768+x]>cut)
    528                 continue;
    529 
    530             //
    531             // FIXME: Create LOOKUP Table!
    532             //
    533 
    534             img[y*768+x] = 0;
    535         }
     499    const byte *e = img+768*576;
     500    byte *i = img;
     501    while (i<e)
     502    {
     503        if (*i<=cut)
     504            *i = 0;
     505        i++;
     506    }
    536507
    537508    //

  • trunk/MagicSoft/Cosy/videodev/CaosFilter.h

    r1810 r2278  
    1919                           byte *buffer, const int col);
    2020
    21     static float Mean(const byte *buffer, const int offset,
    22                       int *min, int *max);
    23 
    24     static float SDev(const byte *buffer, const int offset,
    25                       const double mean);
     21    static void  GetStat(const byte *buffer, const int offset,
     22                         double *mean, double *sdev);
    2623
    2724    static int   GetMeanPosition(const byte *bitmap,

  • trunk/MagicSoft/Cosy/videodev/Filter.cc

    r2019 r2278  
    2424}
    2525
    26 float Filter::Mean(const byte *buffer, const int offset, int *min, int *max)
     26float Filter::Mean(const byte *buffer, const int offset)
    2727{
    2828    double mean = 0.0;
    2929
    30     *min = 0xff;
    31     *max = 0x00;
     30    byte *s  = (byte*)buffer;
     31    const byte *e0 = s+768*576;
    3232
    3333    //
    3434    // calculate mean value
    3535    //
    36     for (int x=offset; x<768-offset; x++)
    37         for (int y=offset; y<576-offset; y++)
    38         {
    39             byte val = buffer[y*768+x];
     36    while (s<e0)
     37    {
     38        const byte *e = s+576-offset;
     39        s += offset;
    4040
    41             mean += val;
     41        while (s<e)
     42            mean += *s++;
    4243
    43             if (val>*max)
    44                 *max = val;
     44        s+=offset;
     45    }
    4546
    46             if (val<*min)
    47                 *min = val;
    48         }
     47    return mean / ((768-2*offset)*(576-2*offset));
     48}
    4949
    50     mean /= (768-2*offset)*(576-2*offset);
    51 
    52     return mean;
    53 }
    5450
    5551float Filter::SDev(const byte *buffer, const int offset, const double mean)
    … …  
    10197    const int offset = 10;
    10298
    103     int max;
    104     int min;
    105 
    106     const float mean = Mean(img, offset, &min, &max);
     99    const float mean = Mean(img, offset);
    107100    const float sdev = SDev(img, offset, mean);
    108101
    109     const float cut = mean + 2.5*sdev;
     102    const byte cut = mean+2.5*sdev>254 ? 254 : (byte)(mean + 2.5*sdev);
    110103
    111104    //
    112105    // clean image from noise
    113106    //
    114     for (int x=0; x<768; x++)
    115         for (int y=0; y<576; y++)
    116         {
    117             if (img[y*768+x]>cut)
    118                 continue;
    119 
    120             //
    121             // FIXME: Create LOOKUP Table!
    122             //
    123 
    124             img[y*768+x] = 0;
    125         }
     107    const byte *e = img+768*576;
     108    byte *i = img;
     109    while (i<e)
     110    {
     111        if (*i<=cut)
     112            *i = 0;
     113        i++;
     114    }
    126115
    127116    //
    … …  
    203192}
    204193
    205 void Filter::Stretch(byte *img)
    206 {
    207     const int offset = 25;
    208 
    209     int max;
    210     int min;
    211 
    212     /*const float mean =*/Mean(img, offset, &min, &max);
    213 
    214     const byte diff = max-min;
    215 
    216     for (int x=0; x<768; x++)
    217         for (int y=0; y<576; y++)
    218         {
    219             byte &b = img[y*768+x];
    220 
    221             if (b<min)
    222             {
    223                 b=0;
    224                 continue;
    225             }
    226             if (b>max)
    227             {
    228                 b=max;
    229                 continue;
    230             }
    231             b -= min;
    232             b *= 255/diff;
    233         }
    234 }

  • trunk/MagicSoft/Cosy/videodev/Filter.h

    r1959 r2278  
    1717                           byte *buffer, const int col);
    1818
    19     static float Mean(const byte *buffer, const int offset,
    20                       int *min, int *max);
     19    static float Mean(const byte *buffer, const int offset);
    2120
    2221    static float SDev(const byte *buffer, const int offset,
    … …  
    2928public:
    3029    static void Execute(byte *img);
    31     static void Stretch(byte *img);
    3230
    3331    ClassDef(Filter, 0)

  • trunk/MagicSoft/Cosy/videodev/Makefile

    r1802 r2278  
    3434           PngReader.cc \
    3535           PixClient.cc \
    36            Filter.cc \
    37            Filter2.cc \
    38            CaosFilter.cc \
     36           PixGetter.cc \
     37           FilterLed.cc \
    3938           Writer.cc
    4039

  • trunk/MagicSoft/Cosy/videodev/PngReader.h

    r1803 r2278  
    1414#endif
    1515
     16#include "PixGetter.h"
     17
    1618class PixClient;
    1719
    1820typedef unsigned char byte;
    1921
    20 class PngReader
     22class PngReader : public PixGetter
    2123{
    2224private:

  • trunk/MagicSoft/Cosy/videodev/VideodevLinkDef.h

    r1802 r2278  
    66
    77#pragma link C++ class Writer+;
    8 #pragma link C++ class Filter+;
    9 #pragma link C++ class Filter2+;
    10 #pragma link C++ class CaosFilter+;
     8//#pragma link C++ class Filter+;
     9//#pragma link C++ class Filter2+;
     10#pragma link C++ class FilterLed+;
     11//#pragma link C++ class CaosFilter+;
    1112
    1213#pragma link C++ class Camera+;
Note: See TracChangeset for help on using the changeset viewer.