krita

kis_basic_math_toolbox.cpp

00001 /*
00002  *  This file is part of the KDE project
00003  *
00004  *  Copyright (c) 2005 Cyrille Berger <cberger@cberger.net>
00005  *
00006  *  This program is free software; you can redistribute it and/or modify
00007  *  it under the terms of the GNU General Public License as published by
00008  *  the Free Software Foundation; either version 2 of the License, or
00009  *  (at your option) any later version.
00010  *
00011  *  This program is distributed in the hope that it will be useful,
00012  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
00013  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00014  *  GNU General Public License for more details.
00015  *
00016  *  You should have received a copy of the GNU General Public License
00017  *  along with this program; if not, write to the Free Software
00018  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
00019  */
00020 
00021 #include "kis_basic_math_toolbox.h"
00022 
00023 KisBasicMathToolbox::KisBasicMathToolbox()
00024     : KisMathToolbox(KisID("Basic"))
00025 {
00026 }
00027 
00028 
00029 KisBasicMathToolbox::~KisBasicMathToolbox()
00030 {
00031 }
00032 
00033 
00034 void KisBasicMathToolbox::wavetrans(KisMathToolbox::KisWavelet* wav, KisMathToolbox::KisWavelet* buff, uint halfsize)
00035 {
00036     uint l = (2*halfsize)*wav->depth*sizeof(float);
00037     for(uint i = 0; i < halfsize; i++)
00038     {
00039         float * itLL = buff->coeffs + i*buff->size*buff->depth;
00040         float * itHL = buff->coeffs + (i*buff->size + halfsize)*buff->depth;
00041         float * itLH = buff->coeffs + (halfsize+i)*buff->size*buff->depth;
00042         float * itHH = buff->coeffs + ( (halfsize+i)*buff->size + halfsize)*buff->depth;
00043         float * itS11 = wav->coeffs + 2*i*wav->size*wav->depth;
00044         float * itS12 = wav->coeffs + (2*i*wav->size+1)*wav->depth;
00045         float * itS21 = wav->coeffs + (2*i+1)*wav->size*wav->depth;
00046         float * itS22 = wav->coeffs + ((2*i+1)*wav->size+1)*wav->depth;
00047         for(uint j = 0; j < halfsize; j++)
00048         {
00049             for( uint k = 0; k < wav->depth; k++)
00050             {
00051                 *(itLL++) = (*itS11 + *itS12 + *itS21 + *itS22) * M_SQRT1_2;
00052                 *(itHL++) = (*itS11 - *itS12 + *itS21 - *itS22) * M_SQRT1_2;
00053                 *(itLH++) = (*itS11 + *itS12 - *itS21 - *itS22) * M_SQRT1_2;
00054                 *(itHH++) = (*(itS11++) - *(itS12++) - *(itS21++) + *(itS22++)) * M_SQRT1_2;
00055             }
00056             itS11 += wav->depth; itS12 += wav->depth;
00057             itS21 += wav->depth; itS22 += wav->depth;
00058         }
00059         emit nextStep();
00060     }
00061     for(uint i = 0; i < halfsize; i++)
00062     {
00063         uint p = i*wav->size*wav->depth;
00064         memcpy(wav->coeffs + p, buff->coeffs + p, l);
00065         p = (i + halfsize )*wav->size*wav->depth;
00066         memcpy(wav->coeffs + p, buff->coeffs + p, l);
00067     }
00068     if(halfsize != 1)
00069     {
00070         wavetrans(wav, buff, halfsize/2);
00071     }
00072 }
00073 
00074 void KisBasicMathToolbox::waveuntrans(KisMathToolbox::KisWavelet* wav, KisMathToolbox::KisWavelet* buff, uint halfsize)
00075 {
00076     uint l = (2*halfsize)*wav->depth*sizeof(float);
00077     for(uint i = 0; i < halfsize; i++)
00078     {
00079         float * itLL = wav->coeffs + i*buff->size*buff->depth;
00080         float * itHL = wav->coeffs + (i*buff->size + halfsize)*buff->depth;
00081         float * itLH = wav->coeffs + (halfsize+i)*buff->size*buff->depth;
00082         float * itHH = wav->coeffs + ( (halfsize+i)*buff->size + halfsize)*buff->depth;
00083         float * itS11 = buff->coeffs + 2*i*wav->size*wav->depth;
00084         float * itS12 = buff->coeffs + (2*i*wav->size+1)*wav->depth;
00085         float * itS21 = buff->coeffs + (2*i+1)*wav->size*wav->depth;
00086         float * itS22 = buff->coeffs + ((2*i+1)*wav->size+1)*wav->depth;
00087         for(uint j = 0; j < halfsize; j++)
00088         {
00089             for( uint k = 0; k < wav->depth; k++)
00090             {
00091                 *(itS11++) = (*itLL + *itHL + *itLH + *itHH)*0.25*M_SQRT2;
00092                 *(itS12++) = (*itLL - *itHL + *itLH - *itHH)*0.25*M_SQRT2;
00093                 *(itS21++) = (*itLL + *itHL - *itLH - *itHH)*0.25*M_SQRT2;
00094                 *(itS22++) = (*(itLL++) - *(itHL++) - *(itLH++) + *(itHH++))*0.25*M_SQRT2;
00095             }
00096             itS11 += wav->depth; itS12 += wav->depth;
00097             itS21 += wav->depth; itS22 += wav->depth;
00098         }
00099         emit nextStep();
00100     }
00101     for(uint i = 0; i < halfsize; i++)
00102     {
00103         uint p = i*wav->size*wav->depth;
00104         memcpy(wav->coeffs + p, buff->coeffs + p, l);
00105         p = (i + halfsize )*wav->size*wav->depth;
00106         memcpy(wav->coeffs + p, buff->coeffs + p, l);
00107     }
00108     
00109     if(halfsize != wav->size/2)
00110     {
00111         waveuntrans(wav, buff, halfsize*2);
00112     }
00113 }
00114 
00115 KisMathToolbox::KisWavelet* KisBasicMathToolbox::fastWaveletTransformation(KisPaintDeviceSP src, const QRect& rect,  KisWavelet* buff)
00116 {
00117     if(buff == 0)
00118     {
00119         buff = initWavelet( src, rect );
00120     }
00121     KisWavelet* wav = initWavelet( src, rect );
00122     transformToFR(src, wav, rect);
00123     wavetrans(wav, buff, wav->size / 2);
00124     
00125     return wav;
00126 }
00127 
00128 void KisBasicMathToolbox::fastWaveletUntransformation(KisPaintDeviceSP dst, const QRect& rect, KisWavelet* wav, KisWavelet* buff)
00129 {
00130     if(buff == 0)
00131     {
00132         buff = initWavelet( dst, rect );
00133     }
00134     
00135     waveuntrans(wav, buff, 1 );
00136     transformFromFR(dst, wav, rect);
00137 }
KDE Home | KDE Accessibility Home | Description of Access Keys