ab.com コミュニティ

お世話になります。
はじめまして、じみっちぃと申します。

いま、とあるサイトに公開されているJAVAプログラムをAB向けに移植しようとしています。
内容は、画像のフィルタリングプログラムなのですが、
JAVAプログラムを自分なりに解析し、ABに書き直してみました。

ところがどうしてもうまく動かず、みなさんのお知恵を拝借できたらと思い
投稿させていただきました。

症状として、なぜかほぼ真っ白な状態になってしまうのです。
JAVAの上では、問題なく動いていたので、アルゴリズムに問題があるとは思えず…

お手数ですが、何かヒントになりそうなことがありましたらご教授いただけませんでしょうか。
よろしくお願いいたします。

移植元のプログラム（JAVA言語）

[ここをクリックすると内容が表示されます]

コード: 全て選択


public class FilterMultiplexscale1 extends Filter
{
  public FilterMultiplexscale1()
  {
    windowSize = 5;
    windowSizeMax = 35;
    windowSizeMin = 1;
    SIGMA = Math.pow(2D, -3D);
    SIGMAMax = 1000D;
    SIGMAMin = 0.0001D;
    I = 16;
    SIGMA2 = new double;
    offset = (windowSize - 1) / 2;
    ND = new double[offset * 2 + 1][offset * 2 + 1];
  }

  void weight(int i)
  {
    int j = offset * 2 + 1;
    double ad[] = new double[j];
    SIGMA2 = Math.sqrt(Math.pow(2D, i - 3));
    double d = 1.0D / Math.sqrt(6.2831853071795862D) / SIGMA2;
    double d1 = 0.0D;
    for(int k = 0; k < j; k++)
    {
      double d2 = k - offset;
      ad[k] = d / Math.exp((d2 * d2) / (2D * SIGMA2 * SIGMA2));
      d1 += ad[k];
    }

    for(int l = 0; l < j; l++)
      ad[l] /= d1;

    for(int i1 = 0; i1 < j; i1++)
    {
      for(int j1 = 0; j1 < j; j1++)
        ND[i1][j1] = ad[i1] * ad[j1];

    }

  }

  public void filter(AnimatedImage animatedimage)
  {
    for(int i = 0; i < I; i++)
      weight(i);

    double d = Math.sqrt(Math.pow(2D, 11D));
    double d1 = Math.sqrt(Math.sqrt(Math.sqrt(Math.sqrt(2D))));
    double ad[] = new double;
    double ad1[] = new double;
    double ad2[] = new double;
    double ad3[] = new double[I];
    double ad4[] = new double[I];
    double ad5[] = new double[I];
    double ad6[] = new double[I];
    double ad7[] = new double[I];
    double ad8[] = new double[I];
    double d4 = 0.0D;
    double d5 = 0.0D;
    double d6 = 0.0D;
    double d7 = 0.5D;
    double d8 = 1.0D;
    char c = '\310';
    char c1 = '\310';
    char c2 = '\310';
    for(int j = 0; j < animatedimage.getHeight(); j++)
    {
      for(int k = 0; k < animatedimage.getWidth(); k++)
      {
        for(int l = 0; l < I; l++)
        {
          double d2 = ad[l] = ad1[l] = ad2[l] = 0.0D;
        }

        for(int i1 = 0; i1 < I; i1++)
          ad5[i1] = ad6[i1] = ad7[i1] = 0.0D;

label0:
        for(int j1 = 0; j1 < I; j1++)
        {
          double d3 = 0.0D;
          if(k - offset < 0 || k + offset >= animatedimage.getWidth() || j - offset < 0 || j + offset >= animatedimage.getHeight())
          {
            for(int j2 = -offset; j2 <= offset; j2++)
            {
              for(int l2 = -offset; l2 <= offset; l2++)
                if(k + j2 >= 0 && k + j2 < animatedimage.getWidth() && j + l2 >= 0 && j + l2 < animatedimage.getHeight())
                {
                  d3 += ND[j1][j2 + offset][l2 + offset];
                  ad[j1] += (double)animatedimage.getR(k + j2, j + l2) * ND[j1][j2 + offset][l2 + offset];
                  ad1[j1] += (double)animatedimage.getG(k + j2, j + l2) * ND[j1][j2 + offset][l2 + offset];
                  ad2[j1] += (double)animatedimage.getB(k + j2, j + l2) * ND[j1][j2 + offset][l2 + offset];
                }

            }

            ad[j1] /= d3;
            ad1[j1] /= d3;
            ad2[j1] /= d3;
            continue;
          }
          int k2 = -offset;
          do
          {
            if(k2 > offset)
              continue label0;
            for(int i3 = -offset; i3 <= offset; i3++)
            {
              ad[j1] += (double)animatedimage.getR(k + k2, j + i3) * ND[j1][k2 + offset][i3 + offset];
              ad1[j1] += (double)animatedimage.getG(k + k2, j + i3) * ND[j1][k2 + offset][i3 + offset];
              ad2[j1] += (double)animatedimage.getB(k + k2, j + i3) * ND[j1][k2 + offset][i3 + offset];
            }

            k2++;
          } while(true);
        }

        for(int k1 = 0; k1 < I; k1++)
          if(k1 <= 2)
            ad3[k1] = 0.0D;
          else
            ad3[k1] = d / Math.sqrt(Math.pow(2D, (k1 + 1) - 3));

        for(int l1 = 0; l1 < I - 1; l1++)
        {
          ad5[l1] = ad[l1 + 1] - ad[l1];
          ad6[l1] = ad1[l1 + 1] - ad1[l1];
          ad7[l1] = ad2[l1 + 1] - ad2[l1];
        }

        for(int i2 = 0; i2 < I - 1; i2++)
        {
          d4 += ad5[i2] * ad3[i2];
          d5 += ad6[i2] * ad3[i2];
          d6 += ad7[i2] * ad3[i2];
        }

        d4 = d4 + d8 + ad[14];
        d5 = d5 + d8 + ad1[14];
        d6 = d6 + d8 + ad2[14];
        d4 = gethanni(d4);
        d5 = gethanni(d5);
        d6 = gethanni(d6);
        animatedimage.setRGB(k, j, (int)Math.rint(d4), (int)Math.rint(d5), (int)Math.rint(d6));
      }

      switchThread();
    }

    switchThread();
    animatedimage.repaintAll();
  }

移植後のプログラム（AB言語）

[ここをクリックすると内容が表示されます]

コード: 全て選択


Sub Filter(hDC_Target As HDC, nWidth As Long, nHeight As Long) As Long

  Dim nSize As Long
  Dim hHeapEA As HANDLE
  Dim hHeapEB As HANDLE
  Dim hHeapEC As HANDLE
  'Dim ND As DWordPtr
  Dim ND As DoublePtr
  Dim dwSrcBits As DWordPtr
  Dim dwDstBits As DWordPtr
  Dim windowSize As Integer
  Dim windowSizeMax As Integer
  Dim windowSizeMin As Integer
  Dim SIGMA As Integer
  Dim SIGMAMax As Integer
  Dim SIGMAMin As Integer
  Dim I As Integer
  Dim offset As Integer
  Dim i As Long
  Dim j As Long
  Dim adAA(17) As Double

  Dim ad(17) As Integer
  Dim adA(17) As Integer
  Dim adB(17) As Integer
  Dim adC(17) As Integer
   'Dim adD(17) As Long
  Dim adE(17) As Integer
  Dim adF(17) As Integer
  Dim adG(17) As Integer
   'Dim adH(17) As Long

  Dim SigmaB(17) As Double
  Dim d As Double

  Dim dA As Long
  Dim k As Long
  Dim dB As Single
  Dim l As Integer
  Dim iA As Long
  Dim jA As Long
  Dim dD As Integer
  Dim dE As Integer
  Dim dF As Integer
  Dim dH As Integer
  Dim dC As Integer
  Dim jB As Integer
  Dim lB As Integer
  Dim kB As Integer
  Dim iC As Integer
  Dim kA As Integer
  Dim lA As Integer
  Dim iB As Integer

  Dim tmpLogA As Double

  'Const Pi = 3.14159265358979323846264
  'Const PiPi = Pi * Pi
  Const PiPi = 6.2831853071795862

  nSize = nWidth * nHeight
  hHeapEB = HeapCreate( NULL, 0, 0 )
  dwSrcBits = HeapAlloc( hHeapEB, HEAP_ZERO_MEMORY, nSize*4 )

  hHeapEC = HeapCreate( NULL, 0, 0 )
  dwDstBits = HeapAlloc( hHeapEB, HEAP_ZERO_MEMORY, nSize*4 )


  For y = 0 To nHeight - 1
    For x = 0 To nWidth - 1
      dwSrcBits[y*nWidth + x] = GetPixel(hDC_Target, x, y)
    Next x
  Next y


  windowSize = 7
  windowSizeMax = 35
  windowSizeMin = 1
  SIGMA = 2^(-3)
  SIGMAMax = 1000
  SIGMAMin = 0.0001
  I = 16
  offset = (windowSize - 1) / 2

  hHeapEA = HeapCreate(NULL, 0, 0)
  ND = HeapAlloc(hHeapEA, HEAP_ZERO_MEMORY, RGB(255,255,255)*SizeOf(Double))

  d = Sqr(2^11)
  dA = Sqr(Sqr(Sqr(Sqr(2))))

  For i = 0 To (I-1)
    j = (offset * 2) + 1
    SigmaB(i) = Sqr( 2^(i-3) )
    d = 1 / Sqr(PiPi) / SigmaB(i)
    dA = 0

    For k = 0 To j-1
      dB = (k - offset) * (k - offset)
      tmpLogA = dB / (2 * SigmaB(i) * SigmaB(i))
      adAA(k) = d / Exp(tmpLogA)
      dA += adAA(k)

    Next k

    For l = 0 To j-1
      adAA(l) /= dA
    Next l

    For iA = 0 To j-1
      For jA = 0 To j-1
        ND[RGB(i,iA,jA)] = adAA(iA) * adAA(jA)
      Next jA
    Next iA
  Next i

  dD = 0
  dE = 0
  dF = 0
  'dG = 0.5
  dH = 1

  For j = 0 To nHeight-1
    For k = 0 To nWidth-1

      For l = 0 To I-1
        dB = 0
        ad(l) = 0
        adA(l) = 0
        adB(l) = 0

        adE(l) = 0
        adF(l) = 0
        adG(l) = 0
      Next l


      For jA = 0 To I-1
        dC = 0
        If (((k - offset < 0) Or (k + offset >= nWidth)) Or ((j - offset < 0) Or (j + offset >= nHeight))) Then
          For jB = 0-offset To offset
            For lB = 0-offset To offset
              If((((k+jB) >= 0) And ((k+jB) < nWidth)) And (((j+lB) >= 0) And ((j+lB) < nHeight))) Then
                dC += (ND[RGB(jA,(jB+offset),(lB+offset))])
                ad(jA) += (GetRed(dwSrcBits[((j+lB)*nWidth) + (k+jB)]) * ND[RGB(jA,(jB+offset),(lB+offset))])
                adA(jA) += (GetGreen(dwSrcBits[((j+lB)*nWidth) + (k+jB)]) * ND[RGB(jA,(jB+offset),(lB+offset))])
                adB(jA) += (GetBlue(dwSrcBits[((j+lB)*nWidth) + (k+jB)]) * ND[RGB(jA,(jB+offset),(lB+offset))])
              End If
            Next lB
          Next jB

          ad(jA) /= dC
          adA(jA) /= dC
          adB(jA) /= dC
          'Continue

        Else
          For kB = (0-offset) To offset
              For iC = 0-offset To offset
                ad(jA)  += (GetRed(dwSrcBits[((j+iC)*nWidth) + (k+kB)]) * ND[RGB(jA,(kB+offset),(iC+offset))])
                adA(jA) += (GetGreen(dwSrcBits[((j+iC)*nWidth) + (k+kB)]) * ND[RGB(jA,(kB+offset),(iC+offset))])
                adB(jA) += (GetBlue(dwSrcBits[((j+iC)*nWidth) + (k+kB)]) * ND[RGB(jA,(kB+offset),(iC+offset))])
              Next iC
          Next kB
        End If
      Next jA

      For kA = 0 To I-1

        If kA <= 2 Then
          adC(kA) = 0
        Else
          adC(kA) = d / Sqr(2^((kA+1)-3))
        End If

        adE(kA) = ad((kA + 1)) - ad(kA)
        adF(kA) = adA((kA + 1)) - adA(kA)
        adG(kA) = adB((kA + 1)) - adB(kA)

        dD += (adE(kA) * adC(kA))
        dE += (adF(kA) * adC(kA))
        dF += (adG(kA) * adC(kA))

      Next kA

      dD = BInt(dD + dH + ad[14])
      dE = BInt(dE + dH + adA[14])
      dF = BInt(dF + dH + adB[14])

      'animatedimage.setRGB(k, j, (int)Math.rint(dD), (int)Math.rint(dE), (int)Math.rint(dF));
      dwDstBits[j*nWidth + k] = RGB(Int(dD),Int(dE),Int(dF))

     Next k
  Next j


  For y = 0 To nHeight - 1
    For x = 0 To nWidth - 1
      SetPixelV(hDC_Target, x, y, dwDstBits[y*nWidth + x])
    Next x
  Next y

  InvalidateRect(hMainWnd, ByVal 0, TRUE)


End Sub


Function BInt(lngNo As Long) As Long

  If lngNo > 255 Then
    BInt = 255
  ElseIf lngNo < 0 Then
    BInt = 0
  Else
    BInt = lngNo
  End If

End Function


Function GetRed(iColor As Long) As Long
  GetRed = &HFF And iColor
End Function


Function GetGreen(iColor As Long) As Long
  GetGreen = (&HFF00 And iColor) \ 256
End Function


Function GetBlue(iColor As Long) As Long
  GetBlue = (&HFF0000 And iColor) \ 65536
End Function

あれからも、色々とMessageBoxとかを使って
そこらじゅうにトラップを仕掛け、値を分析してるんですが…

いまいち原因がつかめない状態です…
Java言語を書いたことが無いんで、色々なJava解説ページ等を参考にして
移植を進めていますが、難しいものですね。

人のプログラムを移植しようとするのも、また難しいものです。
そもそも、元プログラムの処理内容や理論を完全に理解しているわけでないので
そこが一番の問題点だと痛感しています。
へこたれそうですが、なんとか完成させたいものです。

ちなみに、元のプログラムは以下にあります。
http://www.ke.ics.saitama-u.ac.jp/kondo ... index.html
『(3)線画画像（高域強調画像）』というのが、目的の移植しようとしているフィルタです。

かなり面白いフィルタなので、何とかがんばります！

いろいろトライして、プログラム自体は完成したのですが、
処理速度が遅く、また悩みの種が増えてしまいました(^^ゞ

自分なりにループを減らしてみたり、無駄な処理をしないようにして見たり・・・
色々と工夫して見ましたが、P4 2.8G Mem 1G WinXP sp2　でも４分程度かかってしまって…(＠o＠)

みなさんは、画像処理とか重い処理する時、
どうやって処理時間を短縮していますか？
やはりマルチスレッド化ですか？

せっかくですので、ソースコードを乗せておきます。

ソースコード１：

[ここをクリックすると内容が表示されます]

コード: 全て選択



Sub Filter(hDC_Target As HDC, nWidth As Long, nHeight As Long) As Long

Dim nSize As Long
Dim hHeapEB As HANDLE
Dim hHeapEC As HANDLE
Dim dwSrcBits As DWordPtr
Dim dwDstBits As DWordPtr
Dim n As Char
Dim I As Char
Dim Size As Char
Dim Offset As Char
Dim WindowSize As Char
Dim X As Char
Dim SigmaB As Double
Dim k As Double
Dim Total As Double
Dim i As Char
Dim j As Char
Dim T(7) As Double
Dim tmpDouble As Double
Dim ND[16,7,7] As Double
Dim ix As Char
Dim iy As Char
Dim x As Long
Dim y As Long
Dim sumRa As Double
Dim sumGa As Double
Dim sumBa As Double
Dim sumRb As Double
Dim sumGb As Double
Dim sumBb As Double
Dim sumRc As Double
Dim sumGc As Double
Dim sumBc As Double
Dim aA As Double
Dim wA(15) As Double
Dim FRa As Double
Dim FGa As Double
Dim FBa As Double


'■画像の読み込み／書き込みバッファ作成 開始。

nSize = nWidth * nHeight
hHeapEB = HeapCreate( NULL, 0, 0 )
dwSrcBits = HeapAlloc( hHeapEB, HEAP_ZERO_MEMORY, nSize*4 ) 'RGB=24bit ≒ DWord = 4Byte = 32Bit
hHeapEC = HeapCreate( NULL, 0, 0 )
dwDstBits = HeapAlloc( hHeapEC, HEAP_ZERO_MEMORY, nSize*4 ) 'RGB=24bit ≒ DWord = 4Byte = 32Bit

'■画像の読み込み／書き込みバッファ作成 完了。


'▲画像を読み込み 開始。

For y = 0 To nHeight - 1
    For x = 0 To nWidth - 1
       dwSrcBits[y*nWidth + x] = GetPixel(hDC_Target, x, y)
    Next x
Next y

'▲画像を読み込み 完了。


'□重みの計算 開始

    I = 16
    WindowSize = 7
    Offset = (WindowSize-1) / 2  '(7-1)/2 = 3
    Size = (Offset*2)+1  '(3*2)+1 = 7
    aA = Sqr((2^11))
    For n = 0 To I-1
        SigmaB = Sqr((2^(n-3)))
        k = 1.0 / (Sqr(6.2831853071795862) / SigmaB)
        Total = 0
        For i = 0 To Size-1
            X = i - Offset
            tmpDouble = ((X * X) / (2 * SigmaB * SigmaB))
            T(i) = k / (2.7182818284590452353602874713526624977572470936999595749669676277240766303535475945713821785251664274^tmpDouble)
            Total = Total + T(i)
        Next i
        For i = 0 To Size-1
            T(i) = T(i) / Total
        Next i
        For i = 0 To Size-1
            For j = 0 To Size-1
                ND[n,i,j] = T(i) * T(j)
            Next j
        Next i
        If Not(n=0) Then
            If (n-1)<=2 Then
                wA(n) = 0
            Else
                wA(n) = aA / Sqr(2^((n)-3))
            End If
        End If
    Next n

'□重みの計算 完了。

    For y = 0 To nHeight-1
        For x = 0 To nWidth-1
            For n = 0 To I-1
                sumRa = 0
                sumGa = 0
                sumBa = 0
                If x-Offset<0 Or x+Offset>=nWidth Then GOTO *SkipA
                If y-Offset<0 Or y+Offset>=nHeight Then GOTO *SkipA
                '画面中央部
                For ix = -Offset To Offset
                    For iy = -Offset To Offset
                        sumRa += GetRed(dwSrcBits[(y+iy)*nWidth + (x+ix)]) * ND[n,(ix+Offset),(iy+Offset)]
                        sumGa += GetGreen(dwSrcBits[(y+iy)*nWidth + (x+ix)]) * ND[n,(ix+Offset),(iy+Offset)]
                        sumBa += GetBlue(dwSrcBits[(y+iy)*nWidth + (x+ix)]) * ND[n,(ix+Offset),(iy+Offset)]
                    Next iy
                Next ix
                GOTO *SkipB
                '画面の端部
                *SkipA
                Total=0
                For ix = -Offset To Offset
                    If x+ix<0 OR x+ix>=nWidth Then GOTO *SkipIX
                    For iy = -Offset To Offset
                        If y+iy<0 OR y+iy>=nHeight Then GOTO *SkipIY
                        Total += ND[n,(ix+Offset),(iy+Offset)]
                        sumRa += (GetRed(dwSrcBits[(y+iy)*nWidth + (x+ix)]) * ND[n,(ix+Offset),(iy+Offset)])
                        sumGa += (GetGreen(dwSrcBits[(y+iy)*nWidth + (x+ix)]) * ND[n,(ix+Offset),(iy+Offset)])
                        sumBa += (GetBlue(dwSrcBits[(y+iy)*nWidth + (x+ix)]) * ND[n,(ix+Offset),(iy+Offset)])
                        *SkipIY
                    Next iy
                    *SkipIX
                Next ix
                sumRa /= Total
                sumGa /= Total
                sumBa /= Total
                *SkipB
                If Not(n=0) Then
                    FRa = FRa + ((sumRa - sumRb) * wA(n))
                    FGa = FGa + ((sumGa - sumGb) * wA(n))
                    FBa = FBa + ((sumBa - sumBb) * wA(n))
                    If n=14 Then
                        sumRc = sumRa
                        sumGc = sumGa
                        sumBc = sumBa
                    End If
                End If
                sumRb = sumRa
                sumGb = sumGa
                sumBb = sumBa
            Next n
            FRa = BInt((FRa+1+sumRc))
            FGa = BInt((FGa+1+sumGc))
            FBa = BInt((FBa+1+sumBc))
            dwDstBits[y*nWidth + x] = RGB(FRa,FGa,FBa)
        Next x
    Next y

    For y = 0 To nHeight - 1
        For x = 0 To nWidth - 1
            SetPixelV(hDC_Target, x, y, dwDstBits[y*nWidth + x])
        Next x
    Next y

End Sub

ソースコード２：　（高速化しようとあがいた方…　多少早くなりましたが、無駄にソースが長くなってしまいました…）

[ここをクリックすると内容が表示されます]

コード: 全て選択


Sub Filter(hDC_Target As HDC, nWidth As Long, nHeight As Long) As Long

Dim nSize As Long
Dim hHeapEB As HANDLE
Dim hHeapEC As HANDLE
Dim dwSrcBits As DWordPtr
Dim dwDstBits As DWordPtr
Dim n As Char
Dim I As Char
Dim Size As Char
Dim Offset As Char
Dim WindowSize As Char
Dim X As Char
Dim SigmaB As Double
Dim k As Double
Dim Total As Double
Dim i As Char
Dim j As Char
Dim T(7) As Double
Dim tmpDouble As Double
Dim ND[16,7,7] As Double
Dim ix As Char
Dim iy As Char
Dim x As Long
Dim y As Long
Dim sumRa As Double
Dim sumGa As Double
Dim sumBa As Double
Dim sumRb As Double
Dim sumGb As Double
Dim sumBb As Double
Dim sumRc As Double
Dim sumGc As Double
Dim sumBc As Double
Dim aA As Double
Dim wA(15) As Double
Dim FRa As Double
Dim FGa As Double
Dim FBa As Double

Dim tmpWidthA As Long
Dim tmpWidthB As Long
Dim tmpWidthC As Long
Dim tmpWidthD As Long
Dim tmpWidthE As Long
Dim tmpWidthF As Long
Dim tmpWidthG As Long

Dim tmpHeightA As Long
Dim tmpHeightB As Long
Dim tmpHeightC As Long
Dim tmpHeightE As Long
Dim tmpHeightF As Long
Dim tmpHeightG As Long


'■画像の読み込み／書き込みバッファ作成 開始。

nSize = nWidth * nHeight
hHeapEB = HeapCreate( NULL, 0, 0 )
dwSrcBits = HeapAlloc( hHeapEB, HEAP_ZERO_MEMORY, nSize*4 ) 'RGB=24bit ≒ DWord = 4Byte = 32Bit
hHeapEC = HeapCreate( NULL, 0, 0 )
dwDstBits = HeapAlloc( hHeapEC, HEAP_ZERO_MEMORY, nSize*4 ) 'RGB=24bit ≒ DWord = 4Byte = 32Bit

'■画像の読み込み／書き込みバッファ作成 完了。


'▲画像を読み込み 開始。

For y = 0 To nHeight - 1
    For x = 0 To nWidth - 1
       dwSrcBits[y*nWidth + x] = GetPixel(hDC_Target, x, y)
    Next x
Next y

'▲画像を読み込み 完了。


'□重みの計算 開始

    aA = Sqr((2^11))
    I = 16
    WindowSize = 7
    Offset = (WindowSize-1) / 2  '(7-1)/2 = 3
    Size = (Offset*2)+1  '(3*2)+1 = 7


    For n = 0 To I-1
        SigmaB = Sqr((2^(n-3)))
        k = 1.0 / (Sqr(6.2831853071795862) / SigmaB)
        Total = 0
        For x = 0 To Size-1
            X = x - Offset
            tmpDouble = ((X * X) / (2 * SigmaB * SigmaB))
            T(x) = k / (2.7182818284590452353602874713526624977572470936999595749669676277240766303535475945713821785251664274^tmpDouble)
            Total = Total + T(x)
        Next x
        For x = 0 To Size-1
            T(x) = T(x) / Total
        Next x
        For x = 0 To Size-1
            For y = 0 To Size-1
                ND[n,x,y] = T(x) * T(y)
            Next y
        Next x
        If Not(n=0) Then
            If (n-1)<=2 Then
                wA(n) = 0
            Else
                wA(n) = aA / Sqr(2^((n)-3))
            End If
        End If
    Next n

'□重みの計算 完了。

    For y = 0 To nHeight-1
        For x = 0 To nWidth-1
            tmpWidthA = (y-3)*nWidth
            tmpWidthB = (y-2)*nWidth
            tmpWidthC = (y-1)*nWidth
            tmpWidthD = y*nWidth
            tmpWidthE = (y+1)*nWidth
            tmpWidthF = (y+2)*nWidth
            tmpWidthG = (y+3)*nWidth
            tmpHeightA = x-3
            tmpHeightB = x-2
            tmpHeightC = x-1
            tmpHeightE = x+1
            tmpHeightF = x+2
            tmpHeightG = x+3
            For n = 0 To I-1
                If x-Offset<0 Or x+Offset>=nWidth Then GOTO *SkipA
                If y-Offset<0 Or y+Offset>=nHeight Then GOTO *SkipA
                '画面中央部
                sumRa  = (GetRed(dwSrcBits[tmpWidthA + tmpHeightA]) * ND[n,0,0])
                sumRa += (GetRed(dwSrcBits[tmpWidthA + tmpHeightB]) * ND[n,1,0])
                sumRa += (GetRed(dwSrcBits[tmpWidthA + tmpHeightC]) * ND[n,2,0])
                sumRa += (GetRed(dwSrcBits[tmpWidthA + x]) * ND[n,3,0])
                sumRa += (GetRed(dwSrcBits[tmpWidthA + tmpHeightE]) * ND[n,4,0])
                sumRa += (GetRed(dwSrcBits[tmpWidthA + tmpHeightF]) * ND[n,5,0])
                sumRa += (GetRed(dwSrcBits[tmpWidthA + tmpHeightG]) * ND[n,6,0])
                sumRa += (GetRed(dwSrcBits[tmpWidthB + tmpHeightA]) * ND[n,0,1])
                sumRa += (GetRed(dwSrcBits[tmpWidthB + tmpHeightB]) * ND[n,1,1])
                sumRa += (GetRed(dwSrcBits[tmpWidthB + tmpHeightC]) * ND[n,2,1])
                sumRa += (GetRed(dwSrcBits[tmpWidthB + x]) * ND[n,3,1])
                sumRa += (GetRed(dwSrcBits[tmpWidthB + tmpHeightE]) * ND[n,4,1])
                sumRa += (GetRed(dwSrcBits[tmpWidthB + tmpHeightF]) * ND[n,5,1])
                sumRa += (GetRed(dwSrcBits[tmpWidthB + tmpHeightG]) * ND[n,6,1])
                sumRa += (GetRed(dwSrcBits[tmpWidthC + tmpHeightA]) * ND[n,0,2])
                sumRa += (GetRed(dwSrcBits[tmpWidthC + tmpHeightB]) * ND[n,1,2])
                sumRa += (GetRed(dwSrcBits[tmpWidthC + tmpHeightC]) * ND[n,2,2])
                sumRa += (GetRed(dwSrcBits[tmpWidthC + x]) * ND[n,3,2])
                sumRa += (GetRed(dwSrcBits[tmpWidthC + tmpHeightE]) * ND[n,4,2])
                sumRa += (GetRed(dwSrcBits[tmpWidthC + tmpHeightF]) * ND[n,5,2])
                sumRa += (GetRed(dwSrcBits[tmpWidthC + tmpHeightG]) * ND[n,6,2])
                sumRa += (GetRed(dwSrcBits[tmpWidthD + tmpHeightA]) * ND[n,0,3])
                sumRa += (GetRed(dwSrcBits[tmpWidthD + tmpHeightB]) * ND[n,1,3])
                sumRa += (GetRed(dwSrcBits[tmpWidthD + tmpHeightC]) * ND[n,2,3])
                sumRa += (GetRed(dwSrcBits[tmpWidthD + x]) * ND[n,3,3])
                sumRa += (GetRed(dwSrcBits[tmpWidthD + tmpHeightE]) * ND[n,4,3])
                sumRa += (GetRed(dwSrcBits[tmpWidthD + tmpHeightF]) * ND[n,5,3])
                sumRa += (GetRed(dwSrcBits[tmpWidthD + tmpHeightG]) * ND[n,6,3])
                sumRa += (GetRed(dwSrcBits[tmpWidthE + tmpHeightA]) * ND[n,0,4])
                sumRa += (GetRed(dwSrcBits[tmpWidthE + tmpHeightB]) * ND[n,1,4])
                sumRa += (GetRed(dwSrcBits[tmpWidthE + tmpHeightC]) * ND[n,2,4])
                sumRa += (GetRed(dwSrcBits[tmpWidthE + x]) * ND[n,3,4])
                sumRa += (GetRed(dwSrcBits[tmpWidthE + tmpHeightE]) * ND[n,4,4])
                sumRa += (GetRed(dwSrcBits[tmpWidthE + tmpHeightF]) * ND[n,5,4])
                sumRa += (GetRed(dwSrcBits[tmpWidthE + tmpHeightG]) * ND[n,6,4])
                sumRa += (GetRed(dwSrcBits[tmpWidthF + tmpHeightA]) * ND[n,0,5])
                sumRa += (GetRed(dwSrcBits[tmpWidthF + tmpHeightB]) * ND[n,1,5])
                sumRa += (GetRed(dwSrcBits[tmpWidthF + tmpHeightC]) * ND[n,2,5])
                sumRa += (GetRed(dwSrcBits[tmpWidthF + x]) * ND[n,3,5])
                sumRa += (GetRed(dwSrcBits[tmpWidthF + tmpHeightE]) * ND[n,4,5])
                sumRa += (GetRed(dwSrcBits[tmpWidthF + tmpHeightF]) * ND[n,5,5])
                sumRa += (GetRed(dwSrcBits[tmpWidthF + tmpHeightG]) * ND[n,6,5])
                sumRa += (GetRed(dwSrcBits[tmpWidthG + tmpHeightA]) * ND[n,0,6])
                sumRa += (GetRed(dwSrcBits[tmpWidthG + tmpHeightB]) * ND[n,1,6])
                sumRa += (GetRed(dwSrcBits[tmpWidthG + tmpHeightC]) * ND[n,2,6])
                sumRa += (GetRed(dwSrcBits[tmpWidthG + x]) * ND[n,3,6])
                sumRa += (GetRed(dwSrcBits[tmpWidthG + tmpHeightE]) * ND[n,4,6])
                sumRa += (GetRed(dwSrcBits[tmpWidthG + tmpHeightF]) * ND[n,5,6])
                sumRa += (GetRed(dwSrcBits[tmpWidthG + tmpHeightG]) * ND[n,6,6])

                sumGa  = (GetGreen(dwSrcBits[tmpWidthA + tmpHeightA]) * ND[n,0,0])
                sumGa += (GetGreen(dwSrcBits[tmpWidthA + tmpHeightB]) * ND[n,1,0])
                sumGa += (GetGreen(dwSrcBits[tmpWidthA + tmpHeightC]) * ND[n,2,0])
                sumGa += (GetGreen(dwSrcBits[tmpWidthA + x]) * ND[n,3,0])
                sumGa += (GetGreen(dwSrcBits[tmpWidthA + tmpHeightE]) * ND[n,4,0])
                sumGa += (GetGreen(dwSrcBits[tmpWidthA + tmpHeightF]) * ND[n,5,0])
                sumGa += (GetGreen(dwSrcBits[tmpWidthA + tmpHeightG]) * ND[n,6,0])
                sumGa += (GetGreen(dwSrcBits[tmpWidthB + tmpHeightA]) * ND[n,0,1])
                sumGa += (GetGreen(dwSrcBits[tmpWidthB + tmpHeightB]) * ND[n,1,1])
                sumGa += (GetGreen(dwSrcBits[tmpWidthB + tmpHeightC]) * ND[n,2,1])
                sumGa += (GetGreen(dwSrcBits[tmpWidthB + x]) * ND[n,3,1])
                sumGa += (GetGreen(dwSrcBits[tmpWidthB + tmpHeightE]) * ND[n,4,1])
                sumGa += (GetGreen(dwSrcBits[tmpWidthB + tmpHeightF]) * ND[n,5,1])
                sumGa += (GetGreen(dwSrcBits[tmpWidthB + tmpHeightG]) * ND[n,6,1])
                sumGa += (GetGreen(dwSrcBits[tmpWidthC + tmpHeightA]) * ND[n,0,2])
                sumGa += (GetGreen(dwSrcBits[tmpWidthC + tmpHeightB]) * ND[n,1,2])
                sumGa += (GetGreen(dwSrcBits[tmpWidthC + tmpHeightC]) * ND[n,2,2])
                sumGa += (GetGreen(dwSrcBits[tmpWidthC + x]) * ND[n,3,2])
                sumGa += (GetGreen(dwSrcBits[tmpWidthC + tmpHeightE]) * ND[n,4,2])
                sumGa += (GetGreen(dwSrcBits[tmpWidthC + tmpHeightF]) * ND[n,5,2])
                sumGa += (GetGreen(dwSrcBits[tmpWidthC + tmpHeightG]) * ND[n,6,2])
                sumGa += (GetGreen(dwSrcBits[tmpWidthD + tmpHeightA]) * ND[n,0,3])
                sumGa += (GetGreen(dwSrcBits[tmpWidthD + tmpHeightB]) * ND[n,1,3])
                sumGa += (GetGreen(dwSrcBits[tmpWidthD + tmpHeightC]) * ND[n,2,3])
                sumGa += (GetGreen(dwSrcBits[tmpWidthD + x]) * ND[n,3,3])
                sumGa += (GetGreen(dwSrcBits[tmpWidthD + tmpHeightE]) * ND[n,4,3])
                sumGa += (GetGreen(dwSrcBits[tmpWidthD + tmpHeightF]) * ND[n,5,3])
                sumGa += (GetGreen(dwSrcBits[tmpWidthD + tmpHeightG]) * ND[n,6,3])
                sumGa += (GetGreen(dwSrcBits[tmpWidthE + tmpHeightA]) * ND[n,0,4])
                sumGa += (GetGreen(dwSrcBits[tmpWidthE + tmpHeightB]) * ND[n,1,4])
                sumGa += (GetGreen(dwSrcBits[tmpWidthE + tmpHeightC]) * ND[n,2,4])
                sumGa += (GetGreen(dwSrcBits[tmpWidthE + x]) * ND[n,3,4])
                sumGa += (GetGreen(dwSrcBits[tmpWidthE + tmpHeightE]) * ND[n,4,4])
                sumGa += (GetGreen(dwSrcBits[tmpWidthE + tmpHeightF]) * ND[n,5,4])
                sumGa += (GetGreen(dwSrcBits[tmpWidthE + tmpHeightG]) * ND[n,6,4])
                sumGa += (GetGreen(dwSrcBits[tmpWidthF + tmpHeightA]) * ND[n,0,5])
                sumGa += (GetGreen(dwSrcBits[tmpWidthF + tmpHeightB]) * ND[n,1,5])
                sumGa += (GetGreen(dwSrcBits[tmpWidthF + tmpHeightC]) * ND[n,2,5])
                sumGa += (GetGreen(dwSrcBits[tmpWidthF + x]) * ND[n,3,5])
                sumGa += (GetGreen(dwSrcBits[tmpWidthF + tmpHeightE]) * ND[n,4,5])
                sumGa += (GetGreen(dwSrcBits[tmpWidthF + tmpHeightF]) * ND[n,5,5])
                sumGa += (GetGreen(dwSrcBits[tmpWidthF + tmpHeightG]) * ND[n,6,5])
                sumGa += (GetGreen(dwSrcBits[tmpWidthG + tmpHeightA]) * ND[n,0,6])
                sumGa += (GetGreen(dwSrcBits[tmpWidthG + tmpHeightB]) * ND[n,1,6])
                sumGa += (GetGreen(dwSrcBits[tmpWidthG + tmpHeightC]) * ND[n,2,6])
                sumGa += (GetGreen(dwSrcBits[tmpWidthG + x]) * ND[n,3,6])
                sumGa += (GetGreen(dwSrcBits[tmpWidthG + tmpHeightE]) * ND[n,4,6])
                sumGa += (GetGreen(dwSrcBits[tmpWidthG + tmpHeightF]) * ND[n,5,6])
                sumGa += (GetGreen(dwSrcBits[tmpWidthG + tmpHeightG]) * ND[n,6,6])

                sumBa  = (GetBlue(dwSrcBits[tmpWidthA + tmpHeightA]) * ND[n,0,0])
                sumBa += (GetBlue(dwSrcBits[tmpWidthA + tmpHeightB]) * ND[n,1,0])
                sumBa += (GetBlue(dwSrcBits[tmpWidthA + tmpHeightC]) * ND[n,2,0])
                sumBa += (GetBlue(dwSrcBits[tmpWidthA + x]) * ND[n,3,0])
                sumBa += (GetBlue(dwSrcBits[tmpWidthA + tmpHeightE]) * ND[n,4,0])
                sumBa += (GetBlue(dwSrcBits[tmpWidthA + tmpHeightF]) * ND[n,5,0])
                sumBa += (GetBlue(dwSrcBits[tmpWidthA + tmpHeightG]) * ND[n,6,0])
                sumBa += (GetBlue(dwSrcBits[tmpWidthB + tmpHeightA]) * ND[n,0,1])
                sumBa += (GetBlue(dwSrcBits[tmpWidthB + tmpHeightB]) * ND[n,1,1])
                sumBa += (GetBlue(dwSrcBits[tmpWidthB + tmpHeightC]) * ND[n,2,1])
                sumBa += (GetBlue(dwSrcBits[tmpWidthB + x]) * ND[n,3,1])
                sumBa += (GetBlue(dwSrcBits[tmpWidthB + tmpHeightE]) * ND[n,4,1])
                sumBa += (GetBlue(dwSrcBits[tmpWidthB + tmpHeightF]) * ND[n,5,1])
                sumBa += (GetBlue(dwSrcBits[tmpWidthB + tmpHeightG]) * ND[n,6,1])
                sumBa += (GetBlue(dwSrcBits[tmpWidthC + tmpHeightA]) * ND[n,0,2])
                sumBa += (GetBlue(dwSrcBits[tmpWidthC + tmpHeightB]) * ND[n,1,2])
                sumBa += (GetBlue(dwSrcBits[tmpWidthC + tmpHeightC]) * ND[n,2,2])
                sumBa += (GetBlue(dwSrcBits[tmpWidthC + x]) * ND[n,3,2])
                sumBa += (GetBlue(dwSrcBits[tmpWidthC + tmpHeightE]) * ND[n,4,2])
                sumBa += (GetBlue(dwSrcBits[tmpWidthC + tmpHeightF]) * ND[n,5,2])
                sumBa += (GetBlue(dwSrcBits[tmpWidthC + tmpHeightG]) * ND[n,6,2])
                sumBa += (GetBlue(dwSrcBits[tmpWidthD + tmpHeightA]) * ND[n,0,3])
                sumBa += (GetBlue(dwSrcBits[tmpWidthD + tmpHeightB]) * ND[n,1,3])
                sumBa += (GetBlue(dwSrcBits[tmpWidthD + tmpHeightC]) * ND[n,2,3])
                sumBa += (GetBlue(dwSrcBits[tmpWidthD + x]) * ND[n,3,3])
                sumBa += (GetBlue(dwSrcBits[tmpWidthD + tmpHeightE]) * ND[n,4,3])
                sumBa += (GetBlue(dwSrcBits[tmpWidthD + tmpHeightF]) * ND[n,5,3])
                sumBa += (GetBlue(dwSrcBits[tmpWidthD + tmpHeightG]) * ND[n,6,3])
                sumBa += (GetBlue(dwSrcBits[tmpWidthE + tmpHeightA]) * ND[n,0,4])
                sumBa += (GetBlue(dwSrcBits[tmpWidthE + tmpHeightB]) * ND[n,1,4])
                sumBa += (GetBlue(dwSrcBits[tmpWidthE + tmpHeightC]) * ND[n,2,4])
                sumBa += (GetBlue(dwSrcBits[tmpWidthE + x]) * ND[n,3,4])
                sumBa += (GetBlue(dwSrcBits[tmpWidthE + tmpHeightE]) * ND[n,4,4])
                sumBa += (GetBlue(dwSrcBits[tmpWidthE + tmpHeightF]) * ND[n,5,4])
                sumBa += (GetBlue(dwSrcBits[tmpWidthE + tmpHeightG]) * ND[n,6,4])
                sumBa += (GetBlue(dwSrcBits[tmpWidthF + tmpHeightA]) * ND[n,0,5])
                sumBa += (GetBlue(dwSrcBits[tmpWidthF + tmpHeightB]) * ND[n,1,5])
                sumBa += (GetBlue(dwSrcBits[tmpWidthF + tmpHeightC]) * ND[n,2,5])
                sumBa += (GetBlue(dwSrcBits[tmpWidthF + x]) * ND[n,3,5])
                sumBa += (GetBlue(dwSrcBits[tmpWidthF + tmpHeightE]) * ND[n,4,5])
                sumBa += (GetBlue(dwSrcBits[tmpWidthF + tmpHeightF]) * ND[n,5,5])
                sumBa += (GetBlue(dwSrcBits[tmpWidthF + tmpHeightG]) * ND[n,6,5])
                sumBa += (GetBlue(dwSrcBits[tmpWidthG + tmpHeightA]) * ND[n,0,6])
                sumBa += (GetBlue(dwSrcBits[tmpWidthG + tmpHeightB]) * ND[n,1,6])
                sumBa += (GetBlue(dwSrcBits[tmpWidthG + tmpHeightC]) * ND[n,2,6])
                sumBa += (GetBlue(dwSrcBits[tmpWidthG + x]) * ND[n,3,6])
                sumBa += (GetBlue(dwSrcBits[tmpWidthG + tmpHeightE]) * ND[n,4,6])
                sumBa += (GetBlue(dwSrcBits[tmpWidthG + tmpHeightF]) * ND[n,5,6])
                sumBa += (GetBlue(dwSrcBits[tmpWidthG + tmpHeightG]) * ND[n,6,6])
                GOTO *SkipB
                '画面の端部
                *SkipA
                Total = 0
                sumRa = 0
                sumGa = 0
                sumBa = 0
                For ix = -Offset To Offset
                    For iy = -Offset To Offset
                        If x+ix<0 OR x+ix>=nWidth Then GOTO *SkipC
                        If y+iy<0 OR y+iy>=nHeight Then GOTO *SkipC
                        Total += ND[n,(ix+Offset),(iy+Offset)]
                        sumRa += (GetRed(dwSrcBits[(y+iy)*nWidth + (x+ix)]) * ND[n,(ix+Offset),(iy+Offset)])
                        sumGa += (GetGreen(dwSrcBits[(y+iy)*nWidth + (x+ix)]) * ND[n,(ix+Offset),(iy+Offset)])
                        sumBa += (GetBlue(dwSrcBits[(y+iy)*nWidth + (x+ix)]) * ND[n,(ix+Offset),(iy+Offset)])
                        *SkipC
                    Next iy
                Next ix
                sumRa /= Total
                sumGa /= Total
                sumBa /= Total
                *SkipB
                If Not(n=0) Then
                    FRa = FRa + ((sumRa - sumRb) * wA(n))
                    FGa = FGa + ((sumGa - sumGb) * wA(n))
                    FBa = FBa + ((sumBa - sumBb) * wA(n))
                    If n=14 Then
                        sumRc = sumRa
                        sumGc = sumGa
                        sumBc = sumBa
                    End If
                End If
                sumRb = sumRa
                sumGb = sumGa
                sumBb = sumBa
            Next n
            FRa = BInt((FRa+1+sumRc))
            FGa = BInt((FGa+1+sumGc))
            FBa = BInt((FBa+1+sumBc))
            dwDstBits[y*nWidth + x] = RGB(FRa,FGa,FBa)
        Next x
    Next y
    For y = 0 To nHeight - 1
        For x = 0 To nWidth - 1
            SetPixelV(hDC_Target, x, y, dwDstBits[y*nWidth + x])
        Next x
    Next y

End Sub

とりあえず関数をなるべく呼ばないように改造してはいかがでしょうか
RGB値を取得している所はマクロを使えそうですし
DWordPtrをBytePtrにキャストして値を直む手もあります
その場合はキャストするのも時間の無駄なので
最初からBytePtrに格納してしまうのも良いかもしれません

コード: 全て選択


'Get**の代替マクロ
Const GetRed(icolor) = iColor And &HFF
Const GetGreen(icolor) = (iColor And &HFF00)>>8
Const GetBlue(icolor) = (iColor And &HFF0000)>>16

コード: 全て選択


'普通の計算、マクロ、関数呼び出しの速度比べ
Const add_m(x,y) = x+y
Function add_f(x As Long,y As Long) As Long
	add_f = x+y
End Function

Dim i As Long,j As Long
Print Time$()
For i=0 To 2^21
	j=3+5
Next
Print Time$()
For i=0 To 2^21
	j=add_m(3,5)
Next
Print Time$()
For i=0 To 2^21
	j=add_f(3,5)
Next
Print Time$()

あ、マクロの引数間違えたorz

コード: 全て選択


Const GetRed(iColor) = iColor And &HFF
Const GetGreen(iColor) = (iColor And &HFF00)>>8
Const GetBlue(iColor) = (iColor And &HFF0000)>>16

trioさんありがとうございます！

Constにはマクロという使い方があるのですね。
感謝です。さっそく試してみます！

今後とのよろしくお願いしますm(__)m

ab.com コミュニティ

Javaから、ABへプログラムを移植しているのですが…

Javaから、ABへプログラムを移植しているのですが…

色々と…

あれから・・・

なるほど(^o^)