volume.cpp

将OpenCV移植到DSP上

/*
 *  Copyright 2003 by Texas Instruments Incorporated.
 *  All rights reserved. Property of Texas Instruments Incorporated.
 *  Restricted rights to use, duplicate or disclose this code are
 *  granted through contract.
 *  
 */
/* "@(#) DSP/BIOS 4.90.270 01-13-05 (barracuda-o07)" */
/***************************************************************************/
/*                                                                         */
/*     V O L U M E . C                                                     */
/*                                                                         */
/*     Audio gain processing in a main loop                                */
/*                                                                         */
/***************************************************************************/

#include "cxcore.h"
#include <stdlib.h>
#include <stdio.h>
#include "_cv.h"
#include "_cxcore.h"
#include "volume.h"

/* Global declarations */

/*void cvShiftDFT(CvArr * src_arr, CvArr * dst_arr )
{
    CvMat * tmp;
    CvMat q1stub, q2stub;
    CvMat q3stub, q4stub;
    CvMat d1stub, d2stub;
    CvMat d3stub, d4stub;
    CvMat * q1, * q2, * q3, * q4;
    CvMat * d1, * d2, * d3, * d4;

    CvSize size = cvGetSize(src_arr);
    CvSize dst_size = cvGetSize(dst_arr);
    int cx, cy;

    if(dst_size.width != size.width || 
       dst_size.height != size.height){
        cvError( CV_StsUnmatchedSizes, "cvShiftDFT", "Source and Destination arrays must have equal sizes", __FILE__, __LINE__ );   
    }

    if(src_arr==dst_arr){
        tmp = cvCreateMat(size.height/2, size.width/2, cvGetElemType(src_arr));
    }
    
    cx = size.width/2;
    cy = size.height/2; // image center

    q1 = cvGetSubRect( src_arr, &q1stub, cvRect(0,0,cx, cy) );
    q2 = cvGetSubRect( src_arr, &q2stub, cvRect(cx,0,cx,cy) );
    q3 = cvGetSubRect( src_arr, &q3stub, cvRect(cx,cy,cx,cy) );
    q4 = cvGetSubRect( src_arr, &q4stub, cvRect(0,cy,cx,cy) );
    d1 = cvGetSubRect( src_arr, &d1stub, cvRect(0,0,cx,cy) );
    d2 = cvGetSubRect( src_arr, &d2stub, cvRect(cx,0,cx,cy) );
    d3 = cvGetSubRect( src_arr, &d3stub, cvRect(cx,cy,cx,cy) );
    d4 = cvGetSubRect( src_arr, &d4stub, cvRect(0,cy,cx,cy) );

    if(src_arr!=dst_arr){
        if( !CV_ARE_TYPES_EQ( q1, d1 )){
            cvError( CV_StsUnmatchedFormats, "cvShiftDFT", "Source and Destination arrays must have the same format", __FILE__, __LINE__ ); 
        }
        cvCopy(q3, d1, 0);
        cvCopy(q4, d2, 0);
        cvCopy(q1, d3, 0);
        cvCopy(q2, d4, 0);
    }
    else{
        cvCopy(q3, tmp, 0);
        cvCopy(q1, q3, 0);
        cvCopy(tmp, q1, 0);
        cvCopy(q4, tmp, 0);
        cvCopy(q2, q4, 0);
        cvCopy(tmp, q2, 0);
    }
}

/*
 * ======== main ========
 */
int main()
{
   	
/*   	CvMat* mat_01,* mat_02,* mat_03;
	mat_01 = cvCreateMat( 3, 3, CV_64FC1 );
	mat_02 = cvCreateMat( 3, 3, CV_64FC1 );
	mat_03 = cvCreateMat( 3, 3, CV_64FC1 );
	double a[9]={1,2,3,
				4,5,6,
				7,8,9};
	cvInitMatHeader(mat_01,3,3,CV_64FC1,a);
	//复制
	mat_02=cvCloneMat(mat_01);
	cvMatMulAdd(mat_01,mat_02,0,mat_03);
	for (int i=0;i<3;i++)
	{
		for (int j=0;j<3;j++)
		{
			printf("%f ",CV_MAT_ELEM(* mat_03,double,i,j));
		}
		printf("\n");
	}
	double test=pow( (CV_MAT_ELEM(* mat_03,double,1,1)-CV_MAT_ELEM( *mat_03,double,1,2)),2 );
	printf("%f",test);
	cvReleaseMat(&mat_01);
	cvReleaseMat(&mat_02);
	cvReleaseMat(&mat_03);
*/
	IplImage * pImag = NULL;
	IplImage * pCannyImag = NULL;
	if ((pImag = cvCreateImage( cvSize( 500, 500 ), 8, 1 )) !=0 )
	{

		pCannyImag = cvCreateImage(cvGetSize(pImag),IPL_DEPTH_8U,1);

		cvCanny(pImag,pCannyImag,50,150,3);

		cvSaveImage("lena1.bmp",pCannyImag);

		cvReleaseImage(&pCannyImag);

		return 0;
	}

/*	IplImage * im;

    IplImage * realInput;
    IplImage * imaginaryInput;
    IplImage * complexInput;
    int dft_M, dft_N;
    CvMat* dft_A, tmp;
    IplImage * image_Re;
    IplImage * image_Im;
    double m, M;

    im = cvCreateImage( cvSize( 500, 500 ), 8, 1 );
    if( !im )
        return -1;

    realInput = cvCreateImage( cvGetSize(im), IPL_DEPTH_64F, 1);
    imaginaryInput = cvCreateImage( cvGetSize(im), IPL_DEPTH_64F, 1);
    complexInput = cvCreateImage( cvGetSize(im), IPL_DEPTH_64F, 2);

    cvScale(im, realInput, 1.0, 0.0);
    cvZero(imaginaryInput);
    cvMerge(realInput, imaginaryInput, NULL, NULL, complexInput);

    dft_M = cvGetOptimalDFTSize( im->height - 1 );
    dft_N = cvGetOptimalDFTSize( im->width - 1 );

    dft_A = cvCreateMat( dft_M, dft_N, CV_64FC2 );
    image_Re = cvCreateImage( cvSize(dft_N, dft_M), IPL_DEPTH_64F, 1);
    image_Im = cvCreateImage( cvSize(dft_N, dft_M), IPL_DEPTH_64F, 1);

    // copy A to dft_A and pad dft_A with zeros
    cvGetSubRect( dft_A, &tmp, cvRect(0,0, im->width, im->height));
    cvCopy( complexInput, &tmp, NULL );
    if( dft_A->cols > im->width )
    {
        cvGetSubRect( dft_A, &tmp, cvRect(im->width,0, dft_A->cols - im->width, im->height));
        cvZero( &tmp );
    }

    // no need to pad bottom part of dft_A with zeros because of
    // use nonzero_rows parameter in cvDFT() call below

    cvDFT( dft_A, dft_A, CV_DXT_FORWARD, complexInput->height );

    // Split Fourier in real and imaginary parts
    cvSplit( dft_A, image_Re, image_Im, 0, 0 );

    // Compute the magnitude of the spectrum Mag = sqrt(Re^2 + Im^2)
    cvPow( image_Re, image_Re, 2.0);
    cvPow( image_Im, image_Im, 2.0);
    cvAdd( image_Re, image_Im, image_Re, NULL);
    cvPow( image_Re, image_Re, 0.5 );

    // Compute log(1 + Mag)
    cvAddS( image_Re, cvScalarAll(1.0), image_Re, NULL ); // 1 + Mag
    cvLog( image_Re, image_Re ); // log(1 + Mag)


    // Rearrange the quadrants of Fourier image so that the origin is at
    // the image center
    cvShiftDFT( image_Re, image_Re );

    cvMinMaxLoc(image_Re, &m, &M, NULL, NULL, NULL);
    cvScale(image_Re, image_Re, 1.0/(M-m), 1.0*(-m)/(M-m));
	cvSaveImage("lena1.bmp", image_Re); 

/*	CvMat* mat_01,* dst,* delta;
	mat_01 = cvCreateMat( 3, 3, CV_64FC1 );
	//dst = cvCreateMat( 3, 3, CV_64FC1 );
	delta = cvCreateMat( 3, 3, CV_64FC1 );

	double a[9]={1,2,3,
		4,5,6,
		7,8,9};
	double b[9]={1,1,1,
		1,1,1,
		3,3,5};

	cvInitMatHeader(mat_01,3,3,CV_64FC1,a);
	cvInitMatHeader(delta,3,3,CV_64FC1,b);

	cvAdd( mat_01,delta, mat_01);

	for (int i=0;i<3;i++)
	{
		for (int j=0;j<3;j++)
		{
			printf("%f",CV_MAT_ELEM(* mat_01,double,i,j));
		}
		printf("\n");
	}
	cvReleaseMat(&mat_01);
	//cvReleaseMat(&dst);
	cvReleaseMat(&delta);
*/  
    puts("volume example end\n");
}

/*
 *  ======== processing ========
 *
 * FUNCTION: apply signal processing transform to input signal.
 *
 * PARAMETERS: address of input and output buffers.
 *
 * RETURN VALUE: TRUE.
 */