void UMaterialGraphNode_Base::AllocateDefaultPins()
{
	check(Pins.Num() == 0);

	CreateInputPins();
	CreateOutputPins();
}
void UK2Node_GetClassDefaults::OnClassPinChanged()
{
	TArray<UEdGraphPin*> OldPins = Pins;
	TArray<UEdGraphPin*> OldOutputPins;

	// Gather all current output pins
	for(int32 PinIndex = 0; PinIndex < OldPins.Num(); ++PinIndex)
	{
		UEdGraphPin* OldPin = OldPins[PinIndex];
		if(OldPin->Direction == EGPD_Output)
		{
			Pins.Remove(OldPin);
			OldOutputPins.Add(OldPin);
		}
	}

	// Clear the current output pin settings (so they don't carry over to the new set)
	ShowPinForProperties.Empty();

	// Create output pins for the new class type
	UClass* InputClass = GetInputClass();
	CreateOutputPins(InputClass);

	// Destroy the previous set of output pins
	DestroyPinList(OldOutputPins);

	// Notify the graph that the node has been changed
	if(UEdGraph* Graph = GetGraph())
	{
		Graph->NotifyGraphChanged();
	}
}
tResult StateControllerNew::Init(cFilter::tInitStage eStage, IException **__exception_ptr)
{
    RETURN_IF_FAILED(cFilter::Init(eStage, __exception_ptr));

    if (StageFirst == eStage)
    {
        RETURN_IF_FAILED(CreateDescriptions(__exception_ptr));
        RETURN_IF_FAILED(CreateInputPins(__exception_ptr));
        RETURN_IF_FAILED(CreateOutputPins(__exception_ptr));
    }
    else if (StageNormal == eStage)
    {
        controllerMode = static_cast<tControllerMode::ControllerModeEnum>(GetPropertyInt(CONTROLLER_MODE_PROPERTY));
        logger.Log(cString::Format("StateController running in %s mode.", tControllerMode::ToString(controllerMode).c_str()).GetPtr());

        if (tControllerMode::Manual == controllerMode && waitTimer == NULL)
        {
            tInt waitTime = 500 * 1000; // 500ms interval
            waitTimer = _kernel->TimerCreate(tTimeStamp(waitTime), 0, static_cast<IRunnable *>(this), NULL, NULL, 0, 0,
                                             cString::Format("%s.timer", OIGetInstanceName()));
        }
    }
    else if (StageGraphReady == eStage)
    {
        currentManeuverID = 0;
        sectionListIndex = -1;
        maneuverListIndex = -1;
        SetState(tCarState::Startup);
    }

    RETURN_NOERROR;
}
//#############################################################################
tResult cMovementAnalyzer::Init(tInitStage eStage, ucom::IException **__exception_ptr)
{
    switch (eStage)
    {
        case StageFirst:
        {
            // create pins
            RETURN_IF_FAILED(CreateInputPins(__exception_ptr));
            RETURN_IF_FAILED(CreateOutputPins(__exception_ptr));

            break;
        }

        case StageNormal:
        {
            break;
        }

        case StageGraphReady:
        {
            m_bIDsSignalSet = tFalse;
            break;
        }
    }

    RETURN_NOERROR;
}
void UK2Node_GetClassDefaults::ReallocatePinsDuringReconstruction(TArray<UEdGraphPin*>& OldPins) 
{
	Super::ReallocatePinsDuringReconstruction(OldPins);

	// Recreate output pins based on the previous input class
	UEdGraphPin* OldClassPin = FindClassPin(OldPins);
	if(UClass* InputClass = GetInputClass(OldClassPin))
	{
		CreateOutputPins(InputClass);
	}
}
void UAnimGraphNode_Base::InternalPinCreation(TArray<UEdGraphPin*>* OldPins)
{
	// preload required assets first before creating pins
	PreloadRequiredAssets();

	const UAnimationGraphSchema* Schema = GetDefault<UAnimationGraphSchema>();
	if (const UStructProperty* NodeStruct = GetFNodeProperty())
	{
		// Display any currently visible optional pins
		{
			FA3NodeOptionalPinManager OptionalPinManager(this, OldPins);
			OptionalPinManager.AllocateDefaultPins(NodeStruct->Struct, NodeStruct->ContainerPtrToValuePtr<uint8>(this));
		}

		// Create the output pin, if needed
		CreateOutputPins();
	}
}
tResult LightMessageLogger::Init(tInitStage eStage, __exception) {
	RETURN_IF_FAILED(cAsyncDataTriggeredFilter::Init(eStage, __exception_ptr));
	if (eStage == StageFirst)
	{

		RETURN_IF_FAILED(tActionStruct_object.StageFirst(__exception_ptr));
		RETURN_IF_FAILED(tFeedbackStruct_object.StageFirst(__exception_ptr));

		// create and register the input and output pin
		RETURN_IF_FAILED(CreateInputPins(__exception_ptr));
		RETURN_IF_FAILED(CreateOutputPins(__exception_ptr));


	} else if (eStage == StageNormal) {

		/* read property whether debug mode is required */
		debugModeEnabled = tBool(GetPropertyBool(LMLO_DEBUG_TO_CONSOLE));
		carIsCarOne = tBool(GetPropertyBool(LMLO_CAR_NAME));

		// invert car names if protperty is enabled
		if(!carIsCarOne) {
			cString tmp_own_car_name = own_car_name;
			own_car_name = respondent_car_name;
			respondent_car_name = tmp_own_car_name;
		}

		// clear file content
		logfile_content.content.clear();
		new_content_counter = 1;

		// clear file
		fstream chat_file;
		chat_file.open("/home/aadc/AADC/utilities/Kuer/data.json", ios::out | ios::trunc);
		chat_file << "";
		chat_file.close();

	} else if (eStage == StageGraphReady) {
		// get size of media samples that has to be assigned later
		RETURN_IF_FAILED(tActionStruct_object.StageGraphReady());
		RETURN_IF_FAILED(tFeedbackStruct_object.StageGraphReady());

	}
	RETURN_NOERROR;
}
tResult FunctionDriver::Init(tInitStage eStage, __exception)
{
    RETURN_IF_FAILED(cFilter::Init(eStage, __exception_ptr));

    if (eStage == StageFirst)
    {
        // create all the pins
        RETURN_IF_FAILED(CreateInputPins(__exception_ptr));
        RETURN_IF_FAILED(CreateOutputPins(__exception_ptr));
    }
    else if (eStage == StageNormal)
    {
        speed = tFloat32(GetPropertyFloat(SPEED_PROPERTY));
        sinWidth = tFloat32(GetPropertyFloat(SINWIDTH_PROPERTY));
        sinLength = tFloat32(GetPropertyFloat(SINLENGTH_PROPERTY));
    }

    RETURN_NOERROR;
}
tResult MarkerEvaluator::Init(tInitStage eStage, __exception)
{
    RETURN_IF_FAILED(cFilter::Init(eStage, __exception_ptr));

    if (eStage == StageFirst)
    {
        RETURN_IF_FAILED(CreateDescriptions(__exception_ptr));
        RETURN_IF_FAILED(CreateInputPins(__exception_ptr));
        RETURN_IF_FAILED(CreateOutputPins(__exception_ptr));
    }
    else if (eStage == StageNormal)
    {
    }
    else if (eStage == StageGraphReady)
    {
    }

    RETURN_NOERROR;
}
tResult YawToSteer::Init(tInitStage eStage, __exception)
{
    RETURN_IF_FAILED(cFilter::Init(eStage, __exception_ptr));
    if (eStage == StageFirst)
    {
        RETURN_IF_FAILED(CreateDescriptions(__exception_ptr));
        RETURN_IF_FAILED(CreateInputPins(__exception_ptr));
        RETURN_IF_FAILED(CreateOutputPins(__exception_ptr));
    }
    else if (eStage == StageNormal)
    {
        compensationValue = GetPropertyFloat(STEERING_COMPANSATION_FACTOR_PROPERTY);
        deviationThreshold = GetPropertyFloat(DEVIATION_THRESHOLD_PROPERTY);
        abruptVariationThreshold = GetPropertyFloat(ABRUPT_VARIATION_THRESHOLD_PROPERTY);
    }
    else if (eStage == StageGraphReady)
    {
        m_bIDsSignalSet = tFalse;
    }
    RETURN_NOERROR;
}
void UK2Node_GetClassDefaults::PostPlacedNewNode()
{
	// Always exclude object array properties for new nodes.
	// @TODO - Could potentially expose object reference values if/when we have support for 'const' input pins.
	bExcludeObjectArrays = true;

	if(UEdGraphPin* ClassPin = FindClassPin(Pins))
	{
		// Default to the owner BP's generated class for "normal" BPs if this is a new node
		const UBlueprint* OwnerBlueprint = GetBlueprint();
		if(OwnerBlueprint != nullptr && OwnerBlueprint->BlueprintType == BPTYPE_Normal)
		{
			ClassPin->DefaultObject = OwnerBlueprint->GeneratedClass;
		}

		if(UClass* InputClass = GetInputClass(ClassPin))
		{
			CreateOutputPins(InputClass);
		}
	}
}
tResult TemporalImage::Init(tInitStage eStage, __exception)
{
    RETURN_IF_FAILED(cFilter::Init(eStage, __exception_ptr));

    if (eStage == StageFirst)
    {
        RETURN_IF_FAILED(CreateInputPins(__exception_ptr));
        RETURN_IF_FAILED(CreateOutputPins(__exception_ptr));
    }
    else if (eStage == StageNormal)
    {
        bufferSize = tUInt(GetPropertyInt(BUFFER_SIZE_PROPERTY));
        method = tUInt8(GetPropertyInt(METHOD_PROPERTY));

        buffer = vector<Mat>(bufferSize);
        for (unsigned int i = 0; i < buffer.size(); ++i)
        {
            buffer[i] = Mat(0, 0, 0);
        }
    }
    else if (eStage == StageGraphReady)
    {
        cObjectPtr<IMediaType> mediaType;
        RETURN_IF_FAILED(videoInputPin.GetMediaType(&mediaType));

        cObjectPtr<IMediaTypeVideo> videoType;
        RETURN_IF_FAILED(mediaType->GetInterface(IID_ADTF_MEDIA_TYPE_VIDEO, (tVoid **) &videoType));

        videoInputFormat = *(videoType->GetFormat());
        videoOutputFormat = *(videoType->GetFormat());
        videoOutputPin.SetFormat(&videoOutputFormat, NULL);

        logger.Log(cString::Format("Input format: %d x %d @ %d Bit", videoInputFormat.nWidth, videoInputFormat.nHeight,
                                   videoInputFormat.nBitsPerPixel).GetPtr(), false);
        logger.Log(cString::Format("Output format: %d x %d @ %d Bit", videoOutputFormat.nWidth, videoOutputFormat.nHeight,
                                   videoOutputFormat.nBitsPerPixel).GetPtr(), false);
    }

    RETURN_NOERROR;
}
tResult ROI::Init(tInitStage eStage, __exception)
{
    RETURN_IF_FAILED(cFilter::Init(eStage, __exception_ptr));

    if (eStage == StageFirst)
    {
        RETURN_IF_FAILED(InitDescriptions(__exception_ptr));
        RETURN_IF_FAILED(CreateInputPins(__exception_ptr));
        RETURN_IF_FAILED(CreateOutputPins(__exception_ptr));
    }
    else if (eStage == StageNormal)
    {
        hoodScanLineNumber = GetPropertyInt(HOOD_SCANLINE_NUMBER_PROPERTY);
        roomScanLineNumber = GetPropertyInt(ROOM_SCANLINE_NUMBER_PROPERTY);
        maxHoodDetectionCount = GetPropertyInt(MAX_HOOD_DETECTION_COUNT_PROPERTY);
        rgbVideoManipulation = GetPropertyInt(RGB_VIDEO_MANIPULATION_PROPERTY);
        depthVideoManipulation = GetPropertyInt(DEPTH_VIDEO_MANIPULATION_PROPERTY);
        isHoodDetectionEnabled = GetPropertyBool(DETECT_HOOD_PROPERTY);
        isRoomDetectionEnabled = GetPropertyBool(DETECT_ROOM_PROPERTY);
        roomHeightManipulation = GetPropertyFloat(ROOM_HEIGHT_MANIPULATION_PROPERTY);

        logger.Log(cString::Format("roomHeightManipulation: %d", roomHeightManipulation).GetPtr(), false);
        logger.Log(cString::Format("hoodScanLineNumber: %d", hoodScanLineNumber).GetPtr(), false);
        logger.Log(cString::Format("roomScanLineNumber: %d", roomScanLineNumber).GetPtr(), false);
        logger.Log(cString::Format("processingWidthPercentage: %d", processingWidthPercentage).GetPtr(), false);
        logger.Log(cString::Format("maxHoodDetectionCount: %d", maxHoodDetectionCount).GetPtr(), false);
        logger.Log(cString::Format("rgbVideoManipulation: %d", rgbVideoManipulation).GetPtr(), false);
        logger.Log(cString::Format("depthVideoManipulation: %d", depthVideoManipulation).GetPtr(), false);
        logger.Log(cString::Format("isHoodDetectionEnabled: %d", isHoodDetectionEnabled).GetPtr(), false);
        logger.Log(cString::Format("isRoomDetectionEnabled: %d", isRoomDetectionEnabled).GetPtr(), false);
    }
    else if (eStage == StageGraphReady)
    {
        // init RGB Video
        cObjectPtr<IMediaType> rgbMediaType;
        RETURN_IF_FAILED(rgbVideoInputPin.GetMediaType(&rgbMediaType));

        cObjectPtr<IMediaTypeVideo> rgbVideoType;
        RETURN_IF_FAILED(rgbMediaType->GetInterface(IID_ADTF_MEDIA_TYPE_VIDEO, (tVoid **) &rgbVideoType));

        rgbVideoInputFormat = *(rgbVideoType->GetFormat());
        rgbVideoOutputFormat = *(rgbVideoType->GetFormat());
        rgbVideoOutputPin.SetFormat(&rgbVideoOutputFormat, NULL);

        // init Depth Video
        cObjectPtr<IMediaType> depthMediaType;
        RETURN_IF_FAILED(depthVideoInputPin.GetMediaType(&depthMediaType));

        cObjectPtr<IMediaTypeVideo> depthVideoType;
        RETURN_IF_FAILED(depthMediaType->GetInterface(IID_ADTF_MEDIA_TYPE_VIDEO, (tVoid **) &depthVideoType));

        depthVideoInputFormat = *(depthVideoType->GetFormat());
        depthVideoOutputFormat = *(depthVideoType->GetFormat());
        depthVideoOutputPin.SetFormat(&depthVideoOutputFormat, NULL);

        logger.Log(cString::Format("RGB Input format: %d x %d @ %d Bit", rgbVideoInputFormat.nWidth, rgbVideoInputFormat.nHeight,
                                   rgbVideoInputFormat.nBitsPerPixel).GetPtr(), false);
        logger.Log(cString::Format("RGB Output format: %d x %d @ %d Bit", rgbVideoOutputFormat.nWidth, rgbVideoOutputFormat.nHeight,
                                   rgbVideoOutputFormat.nBitsPerPixel).GetPtr(), false);

        logger.Log(cString::Format("Depth Input format: %d x %d @ %d Bit", depthVideoInputFormat.nWidth, depthVideoInputFormat.nHeight,
                                   depthVideoInputFormat.nBitsPerPixel).GetPtr(), false);
        logger.Log(cString::Format("Depth Output format: %d x %d @ %d Bit", depthVideoOutputFormat.nWidth, depthVideoOutputFormat.nHeight,
                                   depthVideoOutputFormat.nBitsPerPixel).GetPtr(), false);

        if (depthVideoOutputFormat.nBitsPerPixel != 8)
        {
            THROW_ERROR_DESC(depthVideoOutputFormat.nBitsPerPixel, "Wrong depth video format. Use HTWK_Grayscale in front of this filter.");
        }

        // init processing parameters
        processingData.processingWidth = depthVideoInputFormat.nWidth * (processingWidthPercentage / 100.0);
        processingData.startOffset = (depthVideoInputFormat.nWidth - processingData.processingWidth) / 2;
        processingData.hoodScanLineStepWidth = processingData.processingWidth / (hoodScanLineNumber - 1);
        processingData.roomScanLineStepWidth = processingData.processingWidth / (roomScanLineNumber - 1);

        logger.Log(cString::Format("hoodScanLineNumber: %d", hoodScanLineNumber).GetPtr(), false);
        logger.Log(cString::Format("processingWidthPercentage: %d", processingWidthPercentage).GetPtr(), false);
        logger.Log(cString::Format("processingWidth: %d", processingData.processingWidth).GetPtr(), false);
        logger.Log(cString::Format("startOffset: %d", processingData.startOffset).GetPtr(), false);
        logger.Log(cString::Format("hoodScanLineStepWidth: %d", processingData.hoodScanLineStepWidth).GetPtr(), false);
        logger.Log(cString::Format("roomScanLineStepWidth: %d", processingData.roomScanLineStepWidth).GetPtr(), false);
    }

    RETURN_NOERROR;
}
tResult StateControlManagementSlim::Init(tInitStage eStage, __exception)
{
    RETURN_IF_FAILED(cAsyncDataTriggeredFilter::Init(eStage, __exception_ptr));

    // pins need to be created at StageFirst
    if (eStage == StageFirst)    
    {
    	//LOG_WARNING("StateControlManagement: StageFirst;");

    	/* get Information regarding input and output pins for specific types */
    	RETURN_IF_FAILED(TActionStruct_object.StageFirst(__exception_ptr));
        RETURN_IF_FAILED(TFeedbackStruct_object.StageFirst(__exception_ptr));

    	// create and register the input pin
    	RETURN_IF_FAILED(CreateInputPins(__exception_ptr));
    	RETURN_IF_FAILED(CreateOutputPins(__exception_ptr));

        m_bDebugModeEnabled = GetPropertyBool("Debug Output to Console");
		#ifdef WRITE_DEBUG_OUTPUT_TO_FILE
		// creating logfile log file for SCM
        //LOG_WARNING("SCM: debug mode: 'logging' for scm-data enabled, writing to /opt/scm_log-'date-and-time'.log");
        time_t rawtime;
        struct tm * timeinfo;
        time(&rawtime);
        timeinfo = localtime(&rawtime);
//        cString fileDate = cString(asctime(timeinfo));
//        fileDate.Replace(" ", "_");
//        fileDate.Replace(":", "_");
//        cString logFilename = "/opt/scm_log_" + fileDate + ".log";
//        logFilename.Replace("\n", "");
//		  scm_logfile.open(logFilename, ios::out | ios::trunc);
//		  scm_logfile << "# SCM data log, recorded at: " << asctime(timeinfo) << std::endl;
		//scm_logfile.close();
        size_t N = 80;
        char dateAndTime[N];
        strftime(dateAndTime, N, "%Y_%m_%d-%H_%M_%S", timeinfo);

        cString dateAndTime_str = cString(dateAndTime);
        cString logFilename = "/opt/scm_log_" + cString(dateAndTime) + ".log";
        logFilename.Replace("\n", "");
        LOG_WARNING("SCM: debug mode: 'logging' for scm-data enabled, writing to '" + logFilename + "'.");
		scm_logfile.open(logFilename, ios::out | ios::trunc);
		scm_logfile << "# SCM data log, recorded at: " << asctime(timeinfo) << std::endl;
		#endif

        /* StateController Management*/
        i16CurrentScmManeuverID = -1;
        i16CurrentScmStepID = -1;
        i8CurrentActLvlMode = NOT_INITIALIZED;


    }
    else if (eStage == StageNormal)
    {
    	//LOG_WARNING("StateControlManagement: StageNormal;");
    	m_bPrintStrucModeEnabled = GetPropertyBool("Print Structure to Console");
        // load xml files for defining the structure of the StateController
        tResult scmLoadstate = LoadSCMStructureData();
        if(scmLoadstate < 0) {
        	LOG_ERROR(adtf_util::cString::Format("SCM: Structure could not be loaded!"));
        }
        THROW_IF_FAILED(scmLoadstate);
        if(m_bDebugModeEnabled && scmLoadstate == 0){
        	LOG_WARNING(adtf_util::cString::Format("SCM: Structure loaded successfully!"));
        }

        /* Initialization of SCM after successfully loading structure*/
        i16CurrentScmManeuverID = 0;
        i16CurrentScmStepID = 0;

        /* START StateControl Management in startup-state, wait for first PASSIVE request to start,
         *  e.g. verification of loaded maneuver list from JuryCommunication */
        i8CurrentActLvlMode = PASSIVE;

        if(m_bDebugModeEnabled) LOG_WARNING(adtf_util::cString::Format("SCM: initialized maneuverID, stepID and actLvlmode:Passive"));

    }
    else if(eStage == StageGraphReady)
    {
    	//LOG_WARNING("StateControlManagement: StageGraphReady;");

        // IDs for ActionStruct and FeedbackStruct are set
        RETURN_IF_FAILED(TActionStruct_object.StageGraphReady());
        RETURN_IF_FAILED(TFeedbackStruct_object.StageGraphReady());


        /* START StateControl Management in startup-state (maneuver 0, step 0) in passive mode, wait for response from JCom
         *  that maneuver list was successfully loaded */
        if(m_bDebugModeEnabled) LOG_WARNING(adtf_util::cString::Format("SCM: waiting for feedback from JCom regarding loaded maneuverlist."));
    }
    RETURN_NOERROR;
}