BOOL CBCGPTagManager::ReadPoint (const CString& strValue, CPoint& value)
{
CString strItem;
if (ExcludeTag (strValue, strItem))
{
return ParsePoint (strItem, value);
}
return FALSE;
}
static void ParseArc( OGRLineString* poLS, json_object* poArcsDB, int nArcID,
int bReverse, ScalingParams* psParams)
{
json_object* poArcDB = json_object_array_get_idx(poArcsDB, nArcID);
if( poArcDB == NULL || json_type_array != json_object_get_type(poArcDB) )
return;
int nPoints = json_object_array_length(poArcDB);
double dfAccX = 0, dfAccY = 0;
int nBaseIndice = poLS->getNumPoints();
for(int i=0; i<nPoints; i++)
{
json_object* poPoint = json_object_array_get_idx(poArcDB, i);
double dfX = 0.0, dfY = 0.0;
if( ParsePoint( poPoint, &dfX, &dfY ) )
{
dfAccX += dfX;
dfAccY += dfY;
dfX = dfAccX * psParams->dfScale0 + psParams->dfTranslate0;
dfY = dfAccY * psParams->dfScale1 + psParams->dfTranslate1;
if( i == 0 )
{
if( !bReverse && poLS->getNumPoints() > 0 )
{
poLS->setNumPoints( nBaseIndice + nPoints - 1 );
nBaseIndice --;
continue;
}
else if( bReverse && poLS->getNumPoints() > 0 )
{
poLS->setNumPoints( nBaseIndice + nPoints - 1 );
nPoints --;
if( nPoints == 0 )
break;
}
else
poLS->setNumPoints( nBaseIndice + nPoints );
}
if( !bReverse )
poLS->setPoint(nBaseIndice + i, dfX, dfY);
else
poLS->setPoint(nBaseIndice + nPoints - 1 - i, dfX, dfY);
}
}
}
BOOL CBCGPTagManager::ParseRect (const CString& strItem, CRect& value)
{
CBCGPTagManager tm (strItem);
CString str1;
CString str2;
tm.ExcludeTag (s_Offset, str1);
str1.TrimLeft ();
str1.TrimRight ();
tm.ExcludeTag (s_Size, str2);
str2.TrimLeft ();
str2.TrimRight ();
CPoint pt (0, 0);
CSize sz (0, 0);
if (ParsePoint (str1, pt) && ParseSize (str2, sz))
{
value = CRect (pt, sz);
return TRUE;
}
tm.SetBuffer (strItem);
tm.ExcludeTag (s_LT, str1);
str1.TrimLeft ();
str1.TrimRight ();
tm.ExcludeTag (s_RB, str2);
str2.TrimLeft ();
str2.TrimRight ();
CPoint pt2 (0, 0);
if (ParsePoint (str1, pt) && ParsePoint (str2, pt2))
{
value = CRect (pt, pt2);
return TRUE;
}
CStringArray sa;
CString strL, strT, strR, strB;
tm.SetBuffer (strItem);
tm.ExcludeTag (s_Left, strL);
strL.TrimLeft ();
strL.TrimRight ();
tm.ExcludeTag (s_Top, strT);
strT.TrimLeft ();
strT.TrimRight ();
tm.ExcludeTag (s_Right, strR);
strR.TrimLeft ();
strR.TrimRight ();
tm.ExcludeTag (s_Bottom, strB);
strB.TrimLeft ();
strB.TrimRight ();
if (strL.IsEmpty () || strT.IsEmpty () || strR.IsEmpty () || strB.IsEmpty ())
{
if (!ParseString (tm.GetBuffer (), _T(","), sa, TRUE, FALSE))
{
return FALSE;
}
}
else
{
sa.Add (strL);
sa.Add (strT);
sa.Add (strR);
sa.Add (strB);
}
if (sa.GetSize () == 4)
{
value.left = _ttol(sa[0]);
value.top = _ttol(sa[1]);
value.right = _ttol(sa[2]);
value.bottom = _ttol(sa[3]);
return TRUE;
}
return FALSE;
}
RDTrimAudio::ErrorCode RDTrimAudio::runTrim(const QString &username,
const QString &password)
{
long response_code;
CURL *curl=NULL;
char url[1024];
CURLcode curl_err;
//
// Generate POST Data
//
QString post=QString().sprintf("COMMAND=%d&LOGIN_NAME=%s&PASSWORD=%s&CART_NUMBER=%u&CUT_NUMBER=%u&TRIM_LEVEL=%d",
RDXPORT_COMMAND_TRIMAUDIO,
(const char *)RDFormPost::urlEncode(username),
(const char *)RDFormPost::urlEncode(password),
conv_cart_number,
conv_cut_number,
conv_trim_level);
if((curl=curl_easy_init())==NULL) {
return RDTrimAudio::ErrorInternal;
}
//
// Write out URL as a C string before passing to curl_easy_setopt(),
// otherwise some versions of LibCurl will throw a 'bad/illegal format'
// error.
//
strncpy(url,conv_station->webServiceUrl(conv_config),1024);
curl_easy_setopt(curl,CURLOPT_URL,url);
curl_easy_setopt(curl,CURLOPT_WRITEFUNCTION,RDTrimAudioCallback);
curl_easy_setopt(curl,CURLOPT_WRITEDATA,&conv_xml);
curl_easy_setopt(curl,CURLOPT_POST,1);
curl_easy_setopt(curl,CURLOPT_POSTFIELDS,(const char *)post);
curl_easy_setopt(curl,CURLOPT_TIMEOUT,RD_CURL_TIMEOUT);
switch(curl_err=curl_easy_perform(curl)) {
case CURLE_OK:
break;
case CURLE_UNSUPPORTED_PROTOCOL:
case CURLE_FAILED_INIT:
case CURLE_COULDNT_RESOLVE_PROXY:
case CURLE_PARTIAL_FILE:
case CURLE_HTTP_RETURNED_ERROR:
case CURLE_WRITE_ERROR:
case CURLE_OUT_OF_MEMORY:
case CURLE_OPERATION_TIMEDOUT:
case CURLE_HTTP_POST_ERROR:
default:
//fprintf(stderr,"CURL Error: %s [%d]\n",curl_easy_strerror(curl_err),
//curl_err);
curl_easy_cleanup(curl);
return RDTrimAudio::ErrorInternal;
case CURLE_URL_MALFORMAT:
case CURLE_COULDNT_RESOLVE_HOST:
case CURLE_COULDNT_CONNECT:
case 9: // CURLE_REMOTE_ACCESS_DENIED
curl_easy_cleanup(curl);
return RDTrimAudio::ErrorUrlInvalid;
}
curl_easy_getinfo(curl,CURLINFO_RESPONSE_CODE,&response_code);
curl_easy_cleanup(curl);
switch(response_code) {
case 200:
//printf("XML: %s\n",(const char *)conv_xml);
break;
case 404:
return RDTrimAudio::ErrorNoAudio;
default:
return RDTrimAudio::ErrorService;
}
conv_start_point=ParsePoint("startTrimPoint",conv_xml);
conv_end_point=ParsePoint("endTrimPoint",conv_xml);
return RDTrimAudio::ErrorOk;
}
static void ParseObject(const char* pszId,
json_object* poObj, OGRGeoJSONLayer* poLayer,
json_object* poArcsDB, ScalingParams* psParams)
{
json_object* poType = OGRGeoJSONFindMemberByName(poObj, "type");
if( poType == NULL || json_object_get_type(poType) != json_type_string )
return;
const char* pszType = json_object_get_string(poType);
json_object* poArcsObj = OGRGeoJSONFindMemberByName(poObj, "arcs");
json_object* poCoordinatesObj = OGRGeoJSONFindMemberByName(poObj, "coordinates");
if( strcmp(pszType, "Point") == 0 || strcmp(pszType, "MultiPoint") == 0 )
{
if( poCoordinatesObj == NULL || json_type_array != json_object_get_type(poCoordinatesObj) )
return;
}
else
{
if( poArcsObj == NULL || json_type_array != json_object_get_type(poArcsObj) )
return;
}
if( pszId == NULL )
{
json_object* poId = OGRGeoJSONFindMemberByName(poObj, "id");
if( poId != NULL &&
(json_type_string == json_object_get_type(poId) ||
json_type_int == json_object_get_type(poId)) )
{
pszId = json_object_get_string(poId);
}
}
OGRFeature* poFeature = new OGRFeature(poLayer->GetLayerDefn());
if( pszId != NULL )
poFeature->SetField("id", pszId);
json_object* poProperties = OGRGeoJSONFindMemberByName(poObj, "properties");
if( poProperties != NULL && json_type_object == json_object_get_type(poProperties) )
{
json_object* poName = OGRGeoJSONFindMemberByName(poProperties, "name");
if( poName != NULL && json_type_string == json_object_get_type(poName) )
{
const char* pszName = json_object_get_string(poName);
poFeature->SetField("name", pszName);
}
}
OGRGeometry* poGeom = NULL;
if( strcmp(pszType, "Point") == 0 )
{
double dfX = 0.0, dfY = 0.0;
if( ParsePoint( poCoordinatesObj, &dfX, &dfY ) )
{
dfX = dfX * psParams->dfScale0 + psParams->dfTranslate0;
dfY = dfY * psParams->dfScale1 + psParams->dfTranslate1;
poGeom = new OGRPoint(dfX, dfY);
}
else
poGeom = new OGRPoint();
}
else if( strcmp(pszType, "MultiPoint") == 0 )
{
OGRMultiPoint* poMP = new OGRMultiPoint();
poGeom = poMP;
int nTuples = json_object_array_length(poCoordinatesObj);
for(int i=0; i<nTuples; i++)
{
json_object* poPair = json_object_array_get_idx(poCoordinatesObj, i);
double dfX = 0.0, dfY = 0.0;
if( ParsePoint( poPair, &dfX, &dfY ) )
{
dfX = dfX * psParams->dfScale0 + psParams->dfTranslate0;
dfY = dfY * psParams->dfScale1 + psParams->dfTranslate1;
poMP->addGeometryDirectly(new OGRPoint(dfX, dfY));
}
}
}
else if( strcmp(pszType, "LineString") == 0 )
{
OGRLineString* poLS = new OGRLineString();
poGeom = poLS;
ParseLineString(poLS, poArcsObj, poArcsDB, psParams);
}
else if( strcmp(pszType, "MultiLineString") == 0 )
{
OGRMultiLineString* poMLS = new OGRMultiLineString();
poGeom = poMLS;
ParseMultiLineString(poMLS, poArcsObj, poArcsDB, psParams);
}
else if( strcmp(pszType, "Polygon") == 0 )
{
OGRPolygon* poPoly = new OGRPolygon();
poGeom = poPoly;
ParsePolygon(poPoly, poArcsObj, poArcsDB, psParams);
}
else if( strcmp(pszType, "MultiPolygon") == 0 )
{
OGRMultiPolygon* poMultiPoly = new OGRMultiPolygon();
poGeom = poMultiPoly;
ParseMultiPolygon(poMultiPoly, poArcsObj, poArcsDB, psParams);
}
if( poGeom != NULL )
poFeature->SetGeometryDirectly(poGeom);
poLayer->AddFeature(poFeature);
delete poFeature;
}
