dolfin team mailing list archive

[A Navaei <axnavaei@xxxxxxxxxxxxxx>]

>
> You should be able to just link against DOLFIN. All the information
> you need is provided by pkg-config:
>
>  pkg-config --cflags dolfin
>  pkg-config --libs dolfin

Is this approach platform-independent or are there solutions for other
platforms?

>
>> Once this is
>> compiled as a python module, you can have something like
>>
>> f = itk.ImageToDolfinFunction("dolfin.jpg")
>>
>> as you mentioned previously. Obviously, it you want to call this from
>> c++ you will need linking to both libraries again. It would be helpful
>> if you could have a look at my dofmap question.
>
> I'm not very keen on using it from C++, but if you want to initialize
> a function in C++, you need to have a function space.

Me neither, but there is no choice: we need a way for data conversion
without going through numpy everytime.

> The simplest way
> would be to create a very simple form file and then compile it with
> FFC (using -l dolfin). For example
>
>  element = FiniteElement("Lagrange", "triangle", 1)
>  v = TestFunction(element)
>  u = TrialFunction(element)
>  a = v*u*dx
>
> If you store this in say a file named "P12D.form" you can then use the
> generated class named
>
>  P12DFunctionSpace

I would like the user to have the option of specifying the finite
element corresponded to the image function space. Is there a more
dynamic way of doing this? I guess the following would work if we can
assign the right signature for dofmap, it hides Mesh and DofMap
dependencies in the cunstructor:


class ImageFunctionSpace : public FunctionSpace
{
public:
	ImageFunctionSpace(const ImageType* & imageData, const FiniteElement& element)
	{
		PixelType * buffer = const_cast<PixelType *>
(imageData->GetBufferPointer()); // imageData is an itk image type
instance
		m_ImageData = (double *) (buffer);

		m_ImageSize = image->GetBufferedRegion().GetSize();

		dolfin::Mesh mesh;
		if(ImageDimension == 2)
		{
			mesh = UnitSquare(m_ImageSize[0], m_ImageSize[1]);
		}
		else if(ImageDimension == 3)
		{
			mesh = UnitCube(m_ImageSize[0], m_ImageSize[1], m_ImageSize[2]);
		}

		dolfin::DofMap dofmap("?", mesh); // <-- what's the right signature?
	
		FunctionSpace(mesh, element, dofmap);
	};

	void eval(double* values, const double* x, const Function& v) const;
	{
		if(ImageDimension == 2)
		{
			int i = int((m_ImageSize[0] - 1) * x[0]);
			int j = int((m_ImageSize[1] - 1) * x[1]);
			int index = i + (m_ImageSize[0] * j);
			values[0] = m_ImageData[index];
		}
		else if(ImageDimension == 3)
		{
			int i = int((m_ImageSize[0] - 1) * x[0]);
			int j = int((m_ImageSize[1] - 1) * x[1]);
			int k = int((m_ImageSize[2] - 1) * x[2]);
			int index = i + (m_ImageSize[0] * j) + (m_ImageSize[0] * m_ImageSize[1] * k);
			values[0] = m_ImageData[index];
		}
	}

protected:
	double *m_ImageData;
	int[ImageDimension] m_ImageSize;
};