void CIVCfgMgr::SetDataShowState(int nChannelID, int nState)
{
GetChannelName(nChannelID, szBuf);
TiXmlElement* pChannelEle = TinyXmlUtil::CreateChildEle(
m_pRootEle, szBuf );
pChannelEle->SetAttribute(_DataShowState, nState);
}
IIVCfgMgr::IVVistor CIVCfgMgr::Begin( int nChannelID )
{
assert(m_pRootEle);
GetChannelName(nChannelID, szBuf);
return IVVistor(
TinyXmlUtil::GetChildChildEle(
m_pRootEle, 2, szBuf, _Rule) );
}
void CIVCfgMgr::GetDataShowState(int nChannelID,int& nState)
{
GetChannelName(nChannelID, szBuf);
TiXmlElement* pChannelEle = TinyXmlUtil::CreateChildEle(
m_pRootEle, szBuf );
TinyXmlUtil::GetAttributeData(
pChannelEle, _DataShowState, nState, IV_Show_All);
}
bool CIVCfgMgr::Remove(
int nChannelID,
const IVVistor& Vistor )
{
assert(m_pRootEle);
TiXmlElement* pEle = Ele(Vistor);
if ( pEle == NULL )
{
return false;
}
GetChannelName(nChannelID, szBuf);
TiXmlElement* pChannelEle = TinyXmlUtil::CreateChildEle(
m_pRootEle, szBuf );
return pChannelEle->RemoveChild(pEle);
}
IIVCfgMgr::IVVistor CIVCfgMgr::Add(
int nChannelID,
const WPG_Rule& Rule,
const ScheduleSettings& Sch,
const AlarmOutSettings& Alarm )
{
GetChannelName(nChannelID, szBuf);
TiXmlElement* pChannelEle = TinyXmlUtil::CreateChildEle(
m_pRootEle, szBuf );
TiXmlElement* pRuleEle = new TiXmlElement(_Rule);
if ( !_AddRule(pRuleEle, Rule) )
{
delete pRuleEle;
return End();
}
_AddSchedule(pRuleEle, Sch);
//TinyXmlUtil::SetChildBinaryTextData(pRuleEle, _Schudule, Sch);
TinyXmlUtil::SetChildBinaryTextData(pRuleEle, _AlarmOut, Alarm);
pChannelEle->LinkEndChild(pRuleEle);
return IVVistor(pRuleEle);
}
/**************************************************************************
Description : Erstellen der Log Datei der letzten ermittelten Werte
von ausgewählten WR in eine Datei um 0:00
Parameter : (none)
Return-Value : (none)
Changes : Author, Date, Version, Reason
********************************************************
Dotterweich, 03.09.2007, 0.1, Created
**************************************************************************/
void LogMonatDatei(char *Pfad, char *OutputDatei, int Format)
{
int i = 0;
int j = 0;
int k = 0;
int Zaehler = 1;
char DatumBuffer[DATUMMAX] = {0};
char ZeitpunktBuffer[ZEITPUNKTMAX] = {0};
char DateiBuffer[DATEINAMEPFADMAX] = {0};
BOOL NeueDatei = true;
FILE *Datei = NULL;
char KanalName[KANALNAMEMAX] = {0};
char WertText[KANALWERTTEXTMAX]={0};
int Zeichen = 0;
DWORD KanalHandle;
ausgabe(LOG, DEBUGALLES, "LogMonatDatei gestartet!!!\n");
GetMonat(DatumBuffer, sizeof(DatumBuffer)-1);
GetZeitpunkt(ZeitpunktBuffer, sizeof(ZeitpunktBuffer)-1);
sprintf(DateiBuffer, "%s/%s.%s", Pfad, DatumBuffer, OutputDatei);
ausgabe(LOG, DEBUGALLES, "LogDatei %s erstellen\n", DateiBuffer);
Datei = fopen(DateiBuffer, "r");
ausgabe(LOG, DEBUGALLES, "Überprüfen ob LogDatei %s geöffnet werden kann!!!\n", DateiBuffer);
if (Datei) // Wenn Datei geöffnet werden konnte dann wurde sie bereits erstellt
{ // und es muss kein Dateikopf mehr erstellt werden.
ausgabe(LOG, DEBUGALLES, "LogDatei %s konnte geöffnet werden!!!\n", DateiBuffer);
NeueDatei = false;
fclose(Datei);
}
Datei = fopen(DateiBuffer, "a");
if (!Datei)
{
ausgabe(LOG, DEBUGALLES, "LogDatei %s konnte nicht geöffnet werden!!!\n", DateiBuffer);
return;
}
else
{ // Logdatei wurde zum Schreiben geöffnet
ausgabe(LOG, DEBUGALLES, "Ausgabe in Datei %s wird gestartet.\n", DateiBuffer);
setbuf(Datei, 0); // Pufferung abschalten
// Erstellen des Dateikopfes wenn nötig
if(NeueDatei)
{
fprintf(Datei, "LogMonatDatei erstellt am %s von %s %s\r\n", ZeitpunktBuffer, ProgrammName, ProgrammVersion);
fprintf(Datei, "---------------------------------------------------------------------------------------------------------------------------\r\n");
fprintf(Datei, " \t");
for(i = 1; i <= LogMonatWRAnzahl; i++)
{
for(j = 1; j <= LogMonatKanalAnzahl; j++)
{
KanalHandle = FindChannelName(WRHandles[0], LogMonatKanal[j - 1]);
if(KanalHandle == 0)
{ // Kanal nicht vom WR
// Die Errechneten Kanaele durchsuchen
for(k = 1; k <= ErrechneteKanaeleAnzahl; k++)
{
if(strncmp(LogMonatKanal[j - 1], ErrechneteKanaeleName[k - 1], sizeof(LogMonatKanal[j - 1])-1) == 0)
{
KanalHandle = k;
break;
}
}
if(KanalHandle == 0)
{ // Kanal nicht gefunden
Zeichen = 15;
}
else
{ // Errechneter Kanal
Zeichen = ErrechneteKanaeleZeichen[KanalHandle - 1];
}
}
else
{ // Kanal vom WR
Zeichen = KanalWertZeichenAnzahlMAX(KanalHandle);
}
if(j == 1)
{
char *Temp[20] = {0};
if(strncmp(LogMonatWR[i - 1], "9999999999", 10) == 0)
{
strncpy(Temp, LogMonatSummeUeberschrift, sizeof(Temp)-1);
}
else
{
strncpy(Temp, LogMonatWR[i - 1], sizeof(Temp)-1);
}
if(Zeichen < strlen(Temp))
{
Zeichen = strlen(Temp);
}
fprintf(Datei, "%-*s\t", Zeichen, Temp);
}
else
{
fprintf(Datei, "%*s\t", Zeichen, "");
}
}
}
fprintf(Datei, "\r\nZeitpunkt \t");
for(i = 1; i <= LogMonatWRAnzahl; i++)
{
for(j = 1; j <= LogMonatKanalAnzahl; j++)
{
KanalHandle = FindChannelName(WRHandles[0], LogMonatKanal[j - 1]);
if(KanalHandle == 0)
{ // Kanal nicht vom WR
// Die Errechneten Kanaele durchsuchen
for(k = 1; k <= ErrechneteKanaeleAnzahl; k++)
{
if(strncmp(LogMonatKanal[j - 1], ErrechneteKanaeleName[k - 1], sizeof(LogMonatKanal[j - 1])-1) == 0)
{
KanalHandle = k;
break;
}
}
if(KanalHandle == 0)
{ // Kanal nicht gefunden
fprintf(Datei, "???%*s???\t", LogMonatDateiZeichenAnzahl(j, 15, i)-6, LogMonatKanal[j - 1]);
}
else
{ // Errechneter Kanal
fprintf(Datei, "%*s\t", LogMonatDateiZeichenAnzahl(j, ErrechneteKanaeleZeichen[KanalHandle - 1], i), ErrechneteKanaeleName[KanalHandle - 1]);
}
}
else
{ // Kanal vom WR
GetChannelName(KanalHandle, KanalName, sizeof(KanalName)-1);
fprintf(Datei, "%*s\t", LogMonatDateiZeichenAnzahl(j, KanalWertZeichenAnzahlMAX(KanalHandle), i), KanalName);
}
}
}
}
// AB hier wird die Datei mit Daten gefüttert
fprintf(Datei, "\r\n");
fprintf(Datei, "%s\t", ZeitpunktBuffer);
for(i = 1; i <= LogMonatWRAnzahl; i++)
{
for(j = 1; j <= LogMonatKanalAnzahl; j++)
{
KanalHandle = FindChannelName(WRHandles[0], LogMonatKanal[j - 1]);
if(KanalHandle == 0)
{ // Kanal nicht vom WR
if(GetWertCalcKanalSN(LogMonatKanal[j - 1], LogMonatWR[i - 1], WertText, sizeof(WertText)-1) == -1)
{ // Kanal nicht gefunden
fprintf(Datei, "%*s\t", LogMonatDateiZeichenAnzahl(j, 15, i), "");
}
else
{ // Kanal gefunden
fprintf(Datei, "%*s\t", LogMonatDateiZeichenAnzahl(j, GetZeichenCalcKanal(LogMonatKanal[j - 1]), i), WertText);
}
}
else
{ // Kanal vom WR
KanalAbfragenSN(KanalHandle, LogMonatWR[i - 1], WertText, sizeof(WertText)-1);
fprintf(Datei, "%*s\t", LogMonatDateiZeichenAnzahl(j, KanalWertZeichenAnzahlMAX(KanalHandle), i), WertText);
}
}
}
fclose(Datei);
}
}
/**************************************************************************
Description : Erstellen der Log Dateien
Parameter : (none)
Return-Value : (none)
Changes : Author, Date, Version, Reason
********************************************************
Dotterweich, 01.09.2007, 0.1, Created
**************************************************************************/
void LogDatei(char *Pfad, char *OutputDatei, int Format)
{
int Zaehler = 1;
ausgabe(LOG, DEBUGALLES, "LogDatei gestartet!!!\n");
for(Zaehler = 1; Zaehler <= AnzahlErfassterWR; Zaehler++)
{
BOOL NeueDatei = true;
char NameBuffer[50] = {0};
char TypeBuffer[50] = {0};
DWORD SNBuffer = 0;
char DatumBuffer[20] = {0};
char DateiBuffer[200] = {0};
FILE *Datei = NULL;
GetDeviceName(WRHandles[Zaehler - 1], NameBuffer, sizeof(NameBuffer)-1);
GetDeviceType(WRHandles[Zaehler - 1], TypeBuffer, sizeof(TypeBuffer)-1);
GetDeviceSN(WRHandles[Zaehler - 1], &SNBuffer);
GetDatum(DatumBuffer, sizeof(DatumBuffer)-1);
ausgabe(LOG, DEBUGALLES, "LogDatei für WR %3ld erstellen\n", SNBuffer);
sprintf(DateiBuffer, "%s/%s.%3ld.%s.%s", Pfad, DatumBuffer, SNBuffer, TypeBuffer, OutputDatei);
Datei = fopen(DateiBuffer, "r");
ausgabe(LOG, DEBUGALLES, "Überprüfen ob LogDatei %s geöffnet werden kann!!!\n", DateiBuffer);
if (Datei) // Wenn Datei geöffnet werden konnte dann wurde sie bereits erstellt
{ // und es muss kein Dateikopf mehr erstellt werden.
ausgabe(LOG, DEBUGALLES, "LogDatei %s konnte geöffnet werden!!!\n", DateiBuffer);
NeueDatei = false;
fclose(Datei);
}
Datei = fopen(DateiBuffer, "a");
if (!Datei)
{
ausgabe(LOG, DEBUGMINI, "LogDatei %s konnte nicht geöffnet werden!!!\n", DateiBuffer);
return;
}
else
{
int i = 0;
int j = 0;
int KanalAnzahl = 0;
DWORD KanalHandle;
TChanType KanalType = ALLCHANNELS;
char KanalName[50] = {0};
char WertText[50]={0};
char ZeitpunktBuffer[50] = {0};
ausgabe(LOG, DEBUGALLES, "Ausgabe in Datei %s wird gestartet.\n", DateiBuffer);
setbuf(Datei, 0); // Pufferung abschalten
// Ab hier Ausgaben in Datei
GetZeitpunkt(ZeitpunktBuffer, sizeof(ZeitpunktBuffer)-1);
if(NeueDatei)
{
fprintf(Datei, "LogDatei für WR %3ld erstellt am %s von %s %s\r\n", SNBuffer, ZeitpunktBuffer, ProgrammName, ProgrammVersion);
fprintf(Datei, "---------------------------------------------------------------------------------------------------------------------------\r\n");
fprintf(Datei, "Zeitpunkt \t");
ausgabe(LOG, DEBUGALLES, "LogKanalAnzahl %i\n", LogKanalAnzahl);
for(i = 1; i <= LogKanalAnzahl; i++)
{
KanalHandle = FindChannelName(WRHandles[Zaehler - 1], LogKanal[i - 1]);
ausgabe(LOG, DEBUGALLES, "1. KanalHandle %i\n", KanalHandle);
if(KanalHandle == 0)
{ // Kanal nicht vom WR
// Die Errechneten Kanaele durchsuchen
for(j = 1; j <= ErrechneteKanaeleAnzahl; j++)
{
if(strncmp(LogKanal[i - 1], ErrechneteKanaeleName[j - 1], sizeof(LogKanal[i - 1])-1) == 0)
{
KanalHandle = j;
break;
}
}
if(KanalHandle == 0)
{ // Kanal nicht gefunden
fprintf(Datei, "???%9s???\t", LogKanal[i - 1]);
}
else
{ // Errechneter Kanal
fprintf(Datei, "%*s\t", ErrechneteKanaeleZeichen[KanalHandle - 1], ErrechneteKanaeleName[KanalHandle - 1]);
}
}
else
{ // Kanal vom WR
GetChannelName(KanalHandle, KanalName, sizeof(KanalName)-1);
fprintf(Datei, "%*s\t", KanalWertZeichenAnzahlMAX(KanalHandle), KanalName);
}
}
}
fprintf(Datei, "\r\n");
fprintf(Datei, "%s\t", ZeitpunktBuffer);
for(i = 1; i <= LogKanalAnzahl; i++)
{
KanalHandle = FindChannelName(WRHandles[Zaehler - 1], LogKanal[i - 1]);
if(KanalHandle == 0)
{ // Kanal nicht vom WR
// Die Errechneten Kanaele durchsuchen
for(j = 1; j <= ErrechneteKanaeleAnzahl; j++)
{
if(strncmp(LogKanal[i - 1], ErrechneteKanaeleName[j - 1], sizeof(LogKanal[i - 1])-1) == 0)
{
KanalHandle = j;
break;
}
}
if(KanalHandle == 0)
{ // Kanal nicht gefunden
fprintf(Datei, " \t");
}
else
{ // Errechneter Kanal
fprintf(Datei, "%s\t", ErrechneteKanaeleWert[Zaehler - 1][KanalHandle - 1]);
}
}
else
{ // Kanal vom WR
KanalAbfragen(KanalHandle, WRHandles[Zaehler - 1], WertText, sizeof(WertText)-1); // Abfragen eines Kanales
fprintf(Datei, "%s\t", WertText);
}
}
ausgabe(LOG, DEBUGALLES, "Ausgabe in Dateien ist beendet.\n");
}
fclose(Datei);
}
}
/**************************************************************************
Description : Erstellen der Log Gesamt Dateien
Parameter : (none)
Return-Value : (none)
Changes : Author, Date, Version, Reason
********************************************************
Dotterweich, 22.08.2007, 0.1, Created
**************************************************************************/
void LogGesamtDatei(char *Pfad, char *OutputDatei, int Format)
{
int Zaehler = 1;
ausgabe(LOG, DEBUGMINI, "LogGesamtDatei gestartet!!!\n");
for(Zaehler = 1; Zaehler <= AnzahlErfassterWR; Zaehler++)
{
BOOL NeueDatei = true;
char NameBuffer[50] = {0};
char TypeBuffer[50] = {0};
DWORD SNBuffer = 0;
char DatumBuffer[20] = {0};
char DateiBuffer[200] = {0};
FILE *Datei = NULL;
GetDeviceName(WRHandles[Zaehler - 1], NameBuffer, sizeof(NameBuffer)-1);
GetDeviceType(WRHandles[Zaehler - 1], TypeBuffer, sizeof(TypeBuffer)-1);
GetDeviceSN(WRHandles[Zaehler - 1], &SNBuffer);
GetDatum(DatumBuffer, sizeof(DatumBuffer)-1);
ausgabe(LOG, DEBUGALLES, "LogGesamtDatei für WR %3ld erstellen\n", SNBuffer);
sprintf(DateiBuffer, "%s/%s.%3ld.%s.%s", Pfad, DatumBuffer, SNBuffer, TypeBuffer, OutputDatei);
Datei = fopen(DateiBuffer, "r");
ausgabe(LOG, DEBUGALLES, "Überprüfen ob LogDatei %s geöffnet werden kann!!!\n", DateiBuffer);
if (Datei) // Wenn Datei geöffnet werden konnte dann wurde sie bereits erstellt
{ // und es muss kein Dateikopf mehr erstellt werden.
ausgabe(LOG, DEBUGALLES, "LogDatei %s konnte geöffnet werden!!!\n", DateiBuffer);
NeueDatei = false;
fclose(Datei);
}
Datei = fopen(DateiBuffer, "a");
if (!Datei)
{
ausgabe(LOG, DEBUGMINI, "LogDatei %s konnte nicht geöffnet werden!!!\n", DateiBuffer);
return;
}
else
{
int i = 0;
int KanalAnzahl = 0;
DWORD KanalHandle[KANALMAX];
TChanType KanalType = ALLCHANNELS;
char KanalName[50] = {0};
char WertText[50]={0};
char ZeitpunktBuffer[50] = {0};
ausgabe(LOG, DEBUGALLES, "Ausgabe in Datei %s wird gestartet.\n", DateiBuffer);
setbuf(Datei, 0); // Pufferung abschalten
// Ab hier Ausgaben in Datei
KanalAnzahl = GetChannelHandlesEx(WRHandles[Zaehler - 1], KanalHandle, KANALMAX, KanalType);
GetZeitpunkt(ZeitpunktBuffer, sizeof(ZeitpunktBuffer)-1);
if(NeueDatei)
{
fprintf(Datei, "LogDatei für WR %3ld erstellt am %s von %s %s\r\n", SNBuffer, ZeitpunktBuffer, ProgrammName, ProgrammVersion);
fprintf(Datei, "WR '%s' hat %d Kanäle:\r\n", NameBuffer, KanalAnzahl);
fprintf(Datei, "---------------------------------------------------------------------------------------------------------------------------\r\n");
fprintf(Datei, "Zeitpunkt \t");
// Kanäle der WR
for(i = 0; i < KanalAnzahl; i++)
{
GetChannelName(KanalHandle[i], KanalName, sizeof(KanalName)-1);
fprintf(Datei, "%*s\t", KanalWertZeichenAnzahlMAX(KanalHandle[i]), KanalName);
}
// Die Errechneten Kanaele
for(i = 0; i < ErrechneteKanaeleAnzahl; i++)
{
fprintf(Datei, "%*s\t", ErrechneteKanaeleZeichen[i], ErrechneteKanaeleName[i]);
}
}
fprintf(Datei, "\r\n");
fprintf(Datei, "%s\t", ZeitpunktBuffer);
// Kanäle der WR
for(i = 0; i < KanalAnzahl; i++)
{
KanalAbfragen(KanalHandle[i], WRHandles[Zaehler - 1], WertText, sizeof(WertText)-1); // Abfragen eines Kanales
fprintf(Datei, "%s\t", WertText);
}
// Die Errechneten Kanaele
for(i = 0; i < ErrechneteKanaeleAnzahl; i++)
{
fprintf(Datei, "%s\t", ErrechneteKanaeleWert[Zaehler - 1][i]);
}
ausgabe(LOG, DEBUGALLES, "Ausgabe in Dateien ist beendet.\n");
}
fclose(Datei);
}
}
std::vector<std::shared_ptr<KeyFrameAnimation>> FBXConverter::LoadCurve(FbxAnimLayer* fbxAnimLayer, FbxNode* fbxNode, int32_t frameCount)
{
std::vector<std::shared_ptr<KeyFrameAnimation>> ret;
auto boneName = fbxNode->GetName();
auto transXCurve = fbxNode->LclTranslation.GetCurve(fbxAnimLayer, FBXSDK_CURVENODE_COMPONENT_X);
auto transYCurve = fbxNode->LclTranslation.GetCurve(fbxAnimLayer, FBXSDK_CURVENODE_COMPONENT_Y);
auto transZCurve = fbxNode->LclTranslation.GetCurve(fbxAnimLayer, FBXSDK_CURVENODE_COMPONENT_Z);
auto rotXCurve = fbxNode->LclRotation.GetCurve(fbxAnimLayer, FBXSDK_CURVENODE_COMPONENT_X);
auto rotYCurve = fbxNode->LclRotation.GetCurve(fbxAnimLayer, FBXSDK_CURVENODE_COMPONENT_Y);
auto rotZCurve = fbxNode->LclRotation.GetCurve(fbxAnimLayer, FBXSDK_CURVENODE_COMPONENT_Z);
auto rot = fbxNode->LclRotation.GetCurveNode(fbxAnimLayer);
auto lclR = fbxNode->LclRotation.Get();
auto defRotX = lclR[0];
auto defRotY = lclR[1];
auto defRotZ = lclR[2];
if (rot != nullptr)
{
for (size_t i = 0; i < rot->GetChannelsCount(); i++)
{
auto name = rot->GetChannelName(i);
if (name == "X")
{
defRotX = rot->GetChannelValue(name, defRotX);
}
if (name == "Y")
{
defRotY = rot->GetChannelValue(name, defRotY);
}
if (name == "Z")
{
defRotZ = rot->GetChannelValue(name, defRotZ);
}
}
}
auto sclXCurve = fbxNode->LclScaling.GetCurve(fbxAnimLayer, FBXSDK_CURVENODE_COMPONENT_X);
auto sclYCurve = fbxNode->LclScaling.GetCurve(fbxAnimLayer, FBXSDK_CURVENODE_COMPONENT_Y);
auto sclZCurve = fbxNode->LclScaling.GetCurve(fbxAnimLayer, FBXSDK_CURVENODE_COMPONENT_Z);
if (transXCurve != nullptr)
{
auto c = LoadCurve(transXCurve, frameCount);
c->Name = boneName;
c->Target = AnimationTarget::TX;
ret.push_back(c);
}
if (transYCurve != nullptr)
{
auto c = LoadCurve(transYCurve, frameCount);
c->Name = boneName;
c->Target = AnimationTarget::TY;
ret.push_back(c);
}
if (transZCurve != nullptr)
{
auto c = LoadCurve(transZCurve, frameCount);
c->Name = boneName;
c->Target = AnimationTarget::TZ;
ret.push_back(c);
}
if (rotXCurve != nullptr)
{
auto c = LoadCurve(rotXCurve, frameCount);
c->Name = boneName;
c->Target = AnimationTarget::RX;
ret.push_back(c);
}
if (rotYCurve != nullptr)
{
auto c = LoadCurve(rotYCurve, frameCount);
c->Name = boneName;
c->Target = AnimationTarget::RY;
ret.push_back(c);
}
if (rotZCurve != nullptr)
{
auto c = LoadCurve(rotZCurve, frameCount);
c->Name = boneName;
c->Target = AnimationTarget::RZ;
ret.push_back(c);
}
if (sclXCurve != nullptr)
{
auto c = LoadCurve(sclXCurve, frameCount);
c->Name = boneName;
c->Target = AnimationTarget::SX;
ret.push_back(c);
}
if (sclYCurve != nullptr)
{
auto c = LoadCurve(sclYCurve, frameCount);
c->Name = boneName;
c->Target = AnimationTarget::SY;
ret.push_back(c);
}
if (sclZCurve != nullptr)
{
auto c = LoadCurve(sclZCurve, frameCount);
c->Name = boneName;
c->Target = AnimationTarget::SZ;
ret.push_back(c);
}
for (auto i = 0; i< fbxNode->GetChildCount(); i++)
{
auto kfas = LoadCurve(fbxAnimLayer, fbxNode->GetChild(i), frameCount);
for (auto a : kfas)
{
ret.push_back(a);
}
}
return ret;
}
