ProFeature CreatePoint (ProSelection refAxis, ProSelection refPlane, double dist){
	ProError err;
	ProFeature pntFeat;
	
	ProName w_featName;
	ProName w_pntName;
	ProValue value;
	ProValueData valueData;
	
	ProElement pntTree;
	ProElement elemFeatType;
	ProElement pntType;
	ProElement featName;
	ProElement pnts;
	ProElement pnt;
	ProElement pntName;
	ProElement pntPlaConstrs;
	ProElement pntAxisConstr;
	ProElement pntAxisConstrType;
	ProElement pntAxisConstrRef;
	ProElement pntAxisConstrVal;
	ProElement pntDimConstrs;
	ProElement pntOffsetConstr;
	ProElement pntOffsetConstrType;
	ProElement pntOffsetConstrRef;
	ProElement pntOffsetConstrVal;
	
	ProAsmcomppath compPath;
	ProModelitem mdlModelitem;
	ProSelection featSelection;
	ProErrorlist errors;
	
	//alloc element tree
	err = ProElementAlloc (PRO_E_FEATURE_TREE, &pntTree);
	
	//set feature type
	err = ProElementAlloc (PRO_E_FEATURE_TYPE, &elemFeatType);
	valueData.type = PRO_VALUE_TYPE_INT;
	valueData.v.i = PRO_FEAT_DATUM_POINT;
	err = ProValueAlloc (&value);
	err = ProValueDataSet (value, &valueData);
	err = ProElementValueSet (elemFeatType, value);
	err = ProElemtreeElementAdd (pntTree, NULL, elemFeatType);

	//set point type
	err = ProElementAlloc (PRO_E_DPOINT_TYPE, &pntType);
	valueData.type = PRO_VALUE_TYPE_INT;
	valueData.v.i = PRO_DPOINT_TYPE_GENERAL;
	err = ProValueAlloc (&value);
	err = ProValueDataSet (value, &valueData);
	err = ProElementValueSet (pntType, value);
	err = ProElemtreeElementAdd (pntTree, NULL, pntType);

	//set feature name
	err = ProElementAlloc (PRO_E_STD_FEATURE_NAME, &featName);
	valueData.type = PRO_VALUE_TYPE_WSTRING;
	ProStringToWstring (w_featName, "PNT0" );
	valueData.v.w = w_featName;
	err = ProValueAlloc (&value);
	err = ProValueDataSet (value, &valueData);
	err = ProElementValueSet (featName, value);
	err = ProElemtreeElementAdd (pntTree, NULL, featName);
	
	//alloc point array holder
	err = ProElementAlloc (PRO_E_DPOINT_POINTS_ARRAY, &pnts);
	err = ProElemtreeElementAdd (pntTree, NULL, pnts);
	
	//alloc point and point array
	err = ProElementAlloc (PRO_E_DPOINT_POINT, &pnt);
	err = ProElemtreeElementAdd (pnts, NULL, pnt);

	//set point name
	err = ProElementAlloc (PRO_E_DPOINT_POINT_NAME , &pntName);
	valueData.type = PRO_VALUE_TYPE_WSTRING;
	ProStringToWstring (w_pntName, "PNT0" );
	valueData.v.w = w_pntName;
	err = ProValueAlloc (&value);
	err = ProValueDataSet (value, &valueData);
	err = ProElementValueSet (pntName, value);
	err = ProElemtreeElementAdd (pnt, NULL, pntName);
	
	//placement constraints array
	err = ProElementAlloc (PRO_E_DPOINT_PLA_CONSTRAINTS, &pntPlaConstrs);
	err = ProElemtreeElementAdd (pnt, NULL, pntPlaConstrs);
	
	//placement constraint on axis
	err = ProElementAlloc (PRO_E_DPOINT_PLA_CONSTRAINT, &pntAxisConstr);
	err = ProElemtreeElementAdd (pntPlaConstrs, NULL, pntAxisConstr);
	
	//placement constraint reference (axis)
	err = ProElementAlloc (PRO_E_DPOINT_PLA_CONSTR_REF, &pntAxisConstrRef);
	valueData.type = PRO_VALUE_TYPE_SELECTION;
	valueData.v.r = refAxis;
	err = ProValueAlloc (&value);
	err = ProValueDataSet (value, &valueData);
	err = ProElementValueSet (pntAxisConstrRef, value);
	err = ProElemtreeElementAdd (pntAxisConstr, NULL, pntAxisConstrRef);
	
	//placement constraint type (on)
	err = ProElementAlloc (PRO_E_DPOINT_PLA_CONSTR_TYPE, &pntAxisConstrType);
	valueData.type = PRO_VALUE_TYPE_INT;
	valueData.v.i = PRO_DTMPNT_CONSTR_TYPE_ON;
	err = ProValueAlloc (&value);
	err = ProValueDataSet (value, &valueData);
	err = ProElementValueSet (pntAxisConstrType, value);
	err = ProElemtreeElementAdd (pntAxisConstr, NULL, pntAxisConstrType);
	
	//placement constraint value (0)
	err = ProElementAlloc (PRO_E_DPOINT_PLA_CONSTR_VAL, &pntAxisConstrVal);
	valueData.type = PRO_VALUE_TYPE_DOUBLE;
	valueData.v.d = 0.0;
	err = ProValueAlloc (&value);
	err = ProValueDataSet (value, &valueData);
	err = ProElementValueSet (pntAxisConstrVal, value);
	err = ProElemtreeElementAdd (pntAxisConstr, NULL, pntAxisConstrVal);

	//dimension constraints array
	err = ProElementAlloc (PRO_E_DPOINT_DIM_CONSTRAINTS, &pntDimConstrs);
	err = ProElemtreeElementAdd (pnt, NULL, pntDimConstrs);
	
	//dimension constraint from plane
	err = ProElementAlloc (PRO_E_DPOINT_DIM_CONSTRAINT, &pntOffsetConstr);
	err = ProElemtreeElementAdd (pntDimConstrs, NULL, pntOffsetConstr);
	
	//dimension constraint reference (plane)
	err = ProElementAlloc (PRO_E_DPOINT_DIM_CONSTR_REF, &pntOffsetConstrRef);
	valueData.type = PRO_VALUE_TYPE_SELECTION;
	valueData.v.r = refPlane;
	err = ProValueAlloc (&value);
	err = ProValueDataSet (value, &valueData);
	err = ProElementValueSet (pntOffsetConstrRef, value);
	err = ProElemtreeElementAdd (pntOffsetConstr, NULL, pntOffsetConstrRef);

	//dimension constraint type (offset)
	err = ProElementAlloc (PRO_E_DPOINT_DIM_CONSTR_TYPE, &pntOffsetConstrType);
	valueData.type = PRO_VALUE_TYPE_INT;
	valueData.v.i = PRO_DTMPNT_CONSTR_TYPE_OFFSET;
	err = ProValueAlloc (&value);
	err = ProValueDataSet (value, &valueData);
	err = ProElementValueSet (pntOffsetConstrType, value);
	err = ProElemtreeElementAdd (pntOffsetConstr, NULL, pntOffsetConstrType);
	
	//dimension constraint value (offset value)
	err = ProElementAlloc (PRO_E_DPOINT_DIM_CONSTR_VAL, &pntOffsetConstrVal);
	valueData.type = PRO_VALUE_TYPE_DOUBLE;
	valueData.v.d = dist;
	err = ProValueAlloc (&value);
	err = ProValueDataSet (value, &valueData);
	err = ProElementValueSet (pntOffsetConstrVal, value);
	err = ProElemtreeElementAdd (pntOffsetConstr, NULL, pntOffsetConstrVal);
	
	//get owning model
	err = ProSelectionAsmcomppathGet (refPlane, &compPath);
	err = ProMdlToModelitem (compPath.owner, &mdlModelitem);
	err = ProSelectionAlloc (NULL, &mdlModelitem, &featSelection);
	
	//create feature
	ProFeatureCreateOptions opts[1];
	opts[0] = PRO_FEAT_CR_DEFINE_MISS_ELEMS;
	err = ProFeatureCreate (featSelection,pntTree,opts,1,&pntFeat,&errors);
	
	err = ProElementFree(&pntTree);
	err = ProSelectionFree(&featSelection);
	return pntFeat;
}

ProFeature CreateAxis (ProSelection refThrough){
	ProError err;
	ProFeature axisFeat;
	
	ProValue value;
	ProValueData valueData;
	
	ProElement axisTree;
	ProElement elemFeatType;
	ProElement axisConstrs;
	ProElement axisConstr;
	ProElement axisConstrType;
	ProElement axisConstrRef;
	
	ProAsmcomppath compPath;
	ProModelitem mdlModelitem;
	ProSelection featSelection;
	ProErrorlist errors;
	
	//alloc the element tree
	err = ProElementAlloc (PRO_E_FEATURE_TREE, &axisTree);
	
	//set feature type
	err = ProElementAlloc (PRO_E_FEATURE_TYPE, &elemFeatType);
	valueData.type = PRO_VALUE_TYPE_INT;
	valueData.v.i = PRO_FEAT_DATUM_AXIS;
	err = ProValueAlloc (&value);
	err = ProValueDataSet (value, &valueData);
	err = ProElementValueSet (elemFeatType, value);
	err = ProElemtreeElementAdd (axisTree, NULL, elemFeatType);
	
	//placement constraints array
	err = ProElementAlloc (PRO_E_DTMAXIS_CONSTRAINTS, &axisConstrs);
	err = ProElemtreeElementAdd (axisTree, NULL, axisConstrs);
	
	//placement constraint
	err = ProElementAlloc (PRO_E_DTMAXIS_CONSTRAINT, &axisConstr);
	err = ProElemtreeElementAdd (axisConstrs, NULL, axisConstr);
	
	//placement constraint type (through)
	err = ProElementAlloc (PRO_E_DTMAXIS_CONSTR_TYPE, &axisConstrType);
	valueData.type = PRO_VALUE_TYPE_INT;
	valueData.v.i = PRO_DTMAXIS_CONSTR_TYPE_THRU;
	err = ProValueAlloc (&value);
	err = ProValueDataSet (value, &valueData);
	err = ProElementValueSet (axisConstrType, value);
	err = ProElemtreeElementAdd (axisConstr, NULL, axisConstrType);
	
	//placement constraint reference (cyl. surf., axis, curve)
	err = ProElementAlloc (PRO_E_DTMAXIS_CONSTR_REF, &axisConstrRef);
	valueData.type = PRO_VALUE_TYPE_SELECTION;
	valueData.v.r = refThrough;
	err = ProValueAlloc (&value);
	err = ProValueDataSet (value, &valueData);
	err = ProElementValueSet (axisConstrRef, value);
	err = ProElemtreeElementAdd (axisConstr, NULL, axisConstrRef);
	
	//get owning model
	err = ProSelectionAsmcomppathGet (refThrough, &compPath);
	err = ProMdlToModelitem (compPath.owner, &mdlModelitem);
	err = ProSelectionAlloc (NULL, &mdlModelitem, &featSelection);
	
	//create feature
	err = ProFeatureCreate (featSelection, axisTree, NULL, 0, &axisFeat, &errors);

	err = ProElementFree(&axisTree);
	err = ProSelectionFree(&featSelection);
	
	return axisFeat;
}

void createPinJoint(SAsmData* child, SAsmData* parent, SAsmData* jointData, OpenSim::Model *osm){
	ProError err;
	ProElement childTree;

	err = ProFeatureElemtreeExtract(&(jointData->feat), 
									NULL, 
									PRO_FEAT_EXTRACT_NO_OPTS,
									&childTree);
	if (err == PRO_TK_NO_ERROR){
		ProFeature axis;
		ProFeature point;
		ProReference axisRef;
		ProSelection axisRefSel;
		ProReference translationRef;
		ProSelection translationRefSel;
		ProSelection axisSel;
		ProElement componentConstrRef;
		ProElempath componentConstrRefPath;
		ProElempathItem componentConstrRefPathItems[3];
		ProElement secComponentConstrRef;
		ProElempath secComponentConstrRefPath;
		ProElempathItem secComponentConstrRefPathItems[3];
		
		//get reference of the axis
		componentConstrRefPathItems[0].type = PRO_ELEM_PATH_ITEM_TYPE_ID;
		componentConstrRefPathItems[0].path_item.elem_id = PRO_E_COMPONENT_CONSTRAINTS;
		componentConstrRefPathItems[1].type = PRO_ELEM_PATH_ITEM_TYPE_INDEX;
		componentConstrRefPathItems[1].path_item.elem_id = 0;
		componentConstrRefPathItems[2].type = PRO_ELEM_PATH_ITEM_TYPE_ID;
		componentConstrRefPathItems[2].path_item.elem_id = PRO_E_COMPONENT_COMP_CONSTR_REF;
		err = ProElempathAlloc(&componentConstrRefPath);
		err = ProElempathDataSet(componentConstrRefPath, componentConstrRefPathItems, 3);
		err = ProElemtreeElementGet(childTree,componentConstrRefPath,&componentConstrRef);
		err = ProElementReferenceGet(componentConstrRef,NULL,&axisRef);
		err = ProReferenceToSelection(axisRef,&axisRefSel);
		
		//ertellen der Achse durch eine Achse, zylindrische Fläche, oder eine runde Kurve
		axis = CreateAxis(axisRefSel);
		
		//get reference of the translation
		secComponentConstrRefPathItems[0].type = PRO_ELEM_PATH_ITEM_TYPE_ID;
		secComponentConstrRefPathItems[0].path_item.elem_id = PRO_E_COMPONENT_CONSTRAINTS;
		secComponentConstrRefPathItems[1].type = PRO_ELEM_PATH_ITEM_TYPE_INDEX;
		secComponentConstrRefPathItems[1].path_item.elem_id = 1;
		secComponentConstrRefPathItems[2].type = PRO_ELEM_PATH_ITEM_TYPE_ID;
		secComponentConstrRefPathItems[2].path_item.elem_id = PRO_E_COMPONENT_COMP_CONSTR_REF;
		err = ProElempathAlloc(&secComponentConstrRefPath);
		err = ProElempathDataSet(secComponentConstrRefPath, secComponentConstrRefPathItems, 3);
		err = ProElemtreeElementGet(childTree,secComponentConstrRefPath,&secComponentConstrRef);
		err = ProElementReferenceGet(secComponentConstrRef,NULL,&translationRef);
		err = ProReferenceToSelection(translationRef,&translationRefSel);
		
		//ableiten der Selection von der Achse hier wird der Fehler entstehen nehme ich an
		err = ProFeatureSelectionGet(&axis,&axisSel);
		
		//erstellen des Punktes auf axisSel, mit Versatz 0 auf tanslationRefSel
		point = CreatePoint (axisSel, translationRefSel, 0);
		
		err = ProElempathFree(&componentConstrRefPath);
		err = ProElempathFree(&secComponentConstrRefPath);
		err = ProSelectionFree(&axisSel);
	}
}