C++ WolframLibraryData::MTensor_getIntegerData方法代码示例

/**
 * Constructs a copy of the input tensor with the number of elements,
 * rank, and type appended at the end.
 **/
DLLEXPORT int demo_T_T(WolframLibraryData libData, mint Argc, MArgument *Args, MArgument Res) {
	MTensor T_arg, T_res;
	mint i, rank, type, num, len;
	mint const* dims;
	mint* intData;
	mint* intDataNew;
	mreal* realData;
	mreal* realDataNew;
	int err = LIBRARY_NO_ERROR;
	
	T_arg = MArgument_getMTensor(Args[0]);


	rank = libData->MTensor_getRank(T_arg);
	type = libData->MTensor_getType(T_arg);
	dims = libData->MTensor_getDimensions(T_arg);
	num =  libData->MTensor_getFlattenedLength(T_arg);

	/*
	The result is going to have all the elements, also 
	the length of each dimension, number of elems, rank and type.
	*/
	len = num + rank + 3;

	err = libData->MTensor_new(type, 1, &len, &T_res);
	if (err) return err;

	
	if ( type == MType_Integer) {
		intData = libData->MTensor_getIntegerData(T_arg);
		intDataNew = libData->MTensor_getIntegerData(T_res);
		for ( i = 0; i < num; i++) {
			intDataNew[i] = intData[i];
		}
		for ( i = 0; i < rank; i++) {
			intDataNew[i+num] = dims[i];
		}
		intDataNew[num+rank] = num;
		intDataNew[num+rank+1] = rank;
		intDataNew[num+rank+2] = type;
	}
	else if ( type == MType_Real) {
		realData = libData->MTensor_getRealData(T_arg);
		realDataNew = libData->MTensor_getRealData(T_res);
		for ( i = 0; i < num; i++) {
			realDataNew[i] = realData[i];
		}
		for ( i = 0; i < rank; i++) {
			realDataNew[i+num] = dims[i];
		}
		realDataNew[num+rank] = num;
		realDataNew[num+rank+1] = rank;
		realDataNew[num+rank+2] = type;
	}	
	MArgument_setMTensor(Res, T_res);
	return LIBRARY_NO_ERROR;
}

/* Accepts inputs, but returns nothing */
DLLEXPORT int demoNoResult(WolframLibraryData libData, mint Argc, MArgument *Args, MArgument Res)
{
	MTensor T = MArgument_getMTensor(Args[0]);
	mint *p = libData->MTensor_getIntegerData(T);

	*p = MArgument_getAddress(Res) == 0? 0:1;
	return LIBRARY_NO_ERROR;
}

/**
 * Intended to demonstrate working with rank 0 tensors.
 *
 * The arguments are three tensors.  
 * The first is a rank > 0 real tensor.
 * The second is a rank 0 integer tensor.
 * The third a rank 0 real tensor.
 *
 * The second argument is used as an index to find
 * an element of the first, which is added to the
 * third argument to form the result.
 *
 * The result is returned as a rank 0 real tensor.
 **/
DLLEXPORT int demo_TTT_T(WolframLibraryData libData, mint Argc, MArgument *Args, MArgument Res) {
	MTensor T_arg, T_I_arg, T_R_arg, T_res;
	mint I0;
	mreal R0, R1;
	int err = LIBRARY_NO_ERROR;
	T_arg = MArgument_getMTensor(Args[0]);
	T_I_arg = MArgument_getMTensor(Args[1]);
	T_R_arg = MArgument_getMTensor(Args[2]);
	I0 = (libData->MTensor_getIntegerData(T_I_arg))[0];
	R0 = (libData->MTensor_getRealData(T_R_arg))[0];	
	err = libData->MTensor_getReal( T_arg, &I0, &R1);
	if (err) return err;
	R0 = R0 + R1;

	err = libData->MTensor_new(MType_Integer, 0, NULL, &T_res);
	if (err) return err;
	(libData->MTensor_getIntegerData( T_res))[0] = (mint) R0;
	
	MArgument_setMTensor(Res, T_res);
	return LIBRARY_NO_ERROR;
}

EXTERN_C DLLEXPORT int GrabFrame(WolframLibraryData libData, mint Argc, MArgument * Args, MArgument Res) {

	int err = LIBRARY_NO_ERROR;

	// get a pointer to the byte buffer:
	BYTE *pData;
	hr = VR.getReadBuffer(&pData);

	if (hr == MF_E_END_OF_STREAM)
	{
		libData->Message("endofstream");
		return LIBRARY_FUNCTION_ERROR;
	}

	if (FAILED(hr))
	{
		libData->Message("getdatafail");
		return LIBRARY_FUNCTION_ERROR;
	} 

	// create the rank 3 MTensor
	MTensor T0;
	mint dims[3];
	dims[0] = (mint) VR.m_imageheight;
	dims[1] = (mint) VR.m_imagewidth;
	dims[2] = 3;
	err = libData->MTensor_new(MType_Integer, 3, dims, &T0);

	// fill the MTensor from the byte buffer
	mint *mtdata;
    mtdata = libData->MTensor_getIntegerData(T0);
    int npixels = VR.m_imageheight * VR.m_imagewidth;   

    for (int i = 0; i < npixels; i++) {
		// we read B, G, R, (A) bytes and put R, G, B into the pixel buffer
		mtdata[3 * i    ] = (mint) pData[4 * i + 2]; // R
        mtdata[3 * i + 1] = (mint) pData[4 * i + 1]; // G
        mtdata[3 * i + 2] = (mint) pData[4 * i    ]; // B
	}
    
	// unlock the buffer
	hr = VR.releaseBuffer();
	if (FAILED(hr))
	{
		libData->Message("releaseBufferfail");
		return LIBRARY_FUNCTION_ERROR;
	}

	// return the MTensor to Mathematica
	MArgument_setMTensor(Res, T0);
	return err; 

} 

EXTERN_C DLLEXPORT int SendFrame(WolframLibraryData libData, mint Argc, MArgument * Args, MArgument Res) {

	MTensor T0 = MArgument_getMTensor(Args[0]);
    mint len = libData->MTensor_getFlattenedLength(T0);

	// check that we have the right amount of data
	UINT32 expectedlength = VW.m_height * VW.m_width * 3;

	if (len != (mint) expectedlength)
	{
		libData->Message("dimensionsfail");
		return LIBRARY_FUNCTION_ERROR;
	}

	// get a buffer
	BYTE *pData = NULL;
	hr = VW.getWriteBuffer(&pData);
	if (FAILED(hr))
	{
		libData->Message("getwritebufferfail");
		return LIBRARY_FUNCTION_ERROR;
	}

	// fill the buffer
	mint *mtdata;
    int npixels = len / 3;
    mtdata = libData->MTensor_getIntegerData(T0);
               
    for (int i = 0; i < npixels; i++) {
		// we read R, G, B bytes and put B, G, R, A into the pixel buffer
		pData[4 * i + 2] = (BYTE) mtdata[3 * i    ]; // R
        pData[4 * i + 1] = (BYTE) mtdata[3 * i + 1]; // G
        pData[4 * i    ] = (BYTE) mtdata[3 * i + 2]; // B
        pData[4 * i + 3] = 0;						 // A
	}             
	
	// write the sample
	hr = VW.writeFrame(pData);
	if (FAILED(hr))
	{
		libData->Message("writeFramefail");
		return LIBRARY_FUNCTION_ERROR;
	}

	// return the timestamp to Mathematica
	MArgument_setInteger(Res, VW.m_rtStart);

	return LIBRARY_NO_ERROR;
} 

DLLEXPORT int brusselator_pde_jacobian_positions(WolframLibraryData libData, mint Argc, MArgument *Args, MArgument Res) 
{
	int err;
	mint dims[2];
    mint i, j, k, n, nr;
	mint *jpos;
    MTensor Tres, Targ;
    Targ = MArgument_getMTensor(Args[1]);
    if (libData->MTensor_getType(Targ) != MType_Real) return LIBRARY_TYPE_ERROR;
    if (libData->MTensor_getRank(Targ) != 1) return LIBRARY_RANK_ERROR;
    nr = libData->MTensor_getFlattenedLength(Targ);
    n = nr/2;

	dims[0] = 4 + 8*(n - 2);
	dims[1] = 2;
    err = libData->MTensor_new(MType_Integer, 2, dims, &Tres);
	if (err) return err;
    jpos = libData->MTensor_getIntegerData(Tres);

    /* Decrement n so loop excludes boundaries */
    n--;
	k = 0;

	jpos[k++] = 1; jpos[k++] = 1; /* u[0] bc */
    for (i = 1; i < n; i++) {	
		/* u equations */
		mint r = i + 1;
		jpos[k++] = r; jpos[k++] = i;
		jpos[k++] = r; jpos[k++] = i + 1;
		jpos[k++] = r; jpos[k++] = i + 2;
		jpos[k++] = r; jpos[k++] = i + n + 2;
	}
	jpos[k++] = n + 1; jpos[k++] = n + 1; /* u[n] bc */
	jpos[k++] = n + 2; jpos[k++] = n + 2; /* v[0] bc */
    for (i = 1; i < n; i++) {	
		/* v equations */
		mint r = i + n + 2;
		jpos[k++] = r; jpos[k++] = i + 1;
		jpos[k++] = r; jpos[k++] = i + n + 1;
		jpos[k++] = r; jpos[k++] = i + n + 2;
		jpos[k++] = r; jpos[k++] = i + n + 3;
	}
	jpos[k++] = 2*(n + 1); jpos[k++] = 2*(n + 1); /* v[n] bc */

    MArgument_setMTensor(Res, Tres);
    return 0;
}

/**
 * Same as demo_TI_R, but just to avoid copying
 **/
DLLEXPORT int demo_TT_T(WolframLibraryData libData, mint Argc, MArgument *Args, MArgument Res) {
	MTensor T0, T1, T2;
	mint I0;
	mreal R0;
	int err = LIBRARY_NO_ERROR;
	T0 = MArgument_getMTensor(Args[0]);
	T1 = MArgument_getMTensor(Args[1]);
	I0 = (libData->MTensor_getIntegerData(T1))[0];	
	err = libData->MTensor_getReal( T0, &I0, &R0);
	if (err) return err;

	err = libData->MTensor_new(MType_Real, 0, NULL, &T2);
	if (err) return err;
	(libData->MTensor_getRealData(T2))[0] = R0;
	
	MArgument_setMTensor(Res, T2);
	return LIBRARY_NO_ERROR;
}