/* Sends the leaks to the scheduler. */
int HashMapMatch_SendLeaks (HashMapMatch *map, int (*snr)(char *, size_t)) {
int count = 0;
int i;
char buf[1024];
HashNodeMatch *p;
char *idToString[] = {
"Request",
"PersistentRequest",
"Communicator",
"Datatype"
};
for (i = 0; i < HASH_SIZE; i++) {
for (p = (*map)[i]; p; p = p->next) {
sprintf(buf, "%d %s %s %u %s %d", count, "Leak", idToString[p->type],
(unsigned int) strlen(p->file), p->file, p->line);
if (snr (buf, strlen (buf)) < 0) {
printf ("Client unable to SendnRecv resource leaks\n");
return -1;
}
count++;
}
}
return count;
}
void snk(Param size, float *in){
#if VERBOSE
printf("Execute Snk\n");
#endif
// Compute SNR
float snrVal = snr(in, data_out, size);
printf("SNR %f dB\n", snrVal);
}
void Analysis::filterData(PivData *pivData, FilterOptions filterOptions)
{
// Checking each filtering option and calling external filter functions (included from filters.h)
if (filterOptions.snr()) snr(pivData,filterOptions);
if (filterOptions.imageIntensity()) imageIntensity(pivData,filterOptions);
if (filterOptions.globalRange()) globalRange(pivData,filterOptions);
if (filterOptions.globalStd()) globalStd(pivData,filterOptions);
if (filterOptions.local()) localDetect(pivData,filterOptions);
if (filterOptions.interpolate()) meanInterpolate(pivData, filterOptions);
if (filterOptions.smoothing()) gaussianBlur(pivData, filterOptions);
}
DoubleReal ElutionPeakDetection::computeApexSNR(const MassTrace& tr)
{
DoubleReal snr(0.0);
DoubleReal noise_level(computeMassTraceNoise(tr));
DoubleReal smoothed_apex_int(tr.getMaxIntensity(true));
if (noise_level > 0.0)
{
snr = smoothed_apex_int/noise_level;
}
// std::cout << "snr " << snr << " ";
return snr;
}
void snk(Param size, Cplx16 *in){
#if VERBOSE
printf("Execute Snk\n");
#endif
Cplx32 in_scaled[size];
int scaling = round(log2(data_out[0].real/in[0].real));
for(int i=0; i<size; i++){
in_scaled[i].real = in[i].real << scaling;
in_scaled[i].imag = in[i].imag << scaling;
}
// Compute SNR
float snrVal = snr(in_scaled, data_out, size);
printf("SNR %f dB scaling %d (%d bits)\n", snrVal, 1<<scaling, scaling);
}
DoubleReal ElutionPeakDetection::computeMassTraceSNR(const MassTrace& tr)
{
DoubleReal noise_area(1.0), signal_area(0.0), snr(0.0);
if (tr.getSize() > 0)
{
noise_area = computeMassTraceNoise(tr) * tr.getTraceLength();
signal_area = tr.computePeakArea();
snr = signal_area/noise_area;
}
// std::cout << "snr " << snr << " ";
return snr;
}
//--------------------------------------------------------------------------------------
//
//--------------------------------------------------------------------------------------
void tDataSourcesDialog::RefreshValue()
{
if( m_SelectedSource.IsValid() )
{
if( m_pSourceSelection->DataTypeToSettingId(m_SelectedSource.DataType()) == DDS_GPS )
{
tDigitalData pos( DATA_TYPE_POSITION, m_SelectedSource );
tDigitalData epe( DATA_TYPE_POSITION_ERROR, m_SelectedSource );
tDigitalData snr( DATA_TYPE_GPS_BEST_OF_FOUR_SNR, m_SelectedSource );
m_pValue->setText( QString("%1 %2 %3 %4 %5 %6")
.arg(epe.Caption(true)).arg(epe.ValueStr()).arg(epe.UnitStr())
.arg(snr.Caption(true)).arg(snr.ValueStr())
.arg(pos.ValueStr()) );
}
else
{
tDigitalData data(m_SelectedSource);
if( data.Valid() )
{
tUnitsType unitsType = data.Units();
QString value = data.ValueStr(&unitsType);
QString unit = data.UnitStr(unitsType);
m_pValue->setText( QString("%1 %2 %3")
.arg(data.Caption())
.arg(value).arg( unit ) );
}
else
{
m_pValue->setText( QString("%1 %2")
.arg(data.Caption())
.arg(data.ValueStr()) ); // invalid ("---")
}
}
}
else
{
int count = m_pDataModel->UnselectedCount( m_pTreeView->currentIndex() );
if (count > 0)
m_pValue->setText( tr(" %1 Unselected").arg( count ) );
else
m_pValue->setText( "" );
}
}
int main () {
enable_uart(25);
initENC();
initservos(625,ON,ON);
initPWM10();
initADC();
initcommsunit();
SetDir('B',0,'O');
SetDir('B',1,'O');
SetDir('B',2,'O');
SetDir('B',3,'O');
SetDir('B',4,'I');
SetDir('B',5,'I');
uprintf("Type INIT <enter> to begin\r");
while(strncmp(dumb,"INIT",4) == 1) {
uscanf(dumb,10,ON);
}
//uprintf("AVR Initalized\r");
op = 1;
while (op == 1) {
uscanf(ReceiveStr,50,ON);
if(strncmp(ReceiveStr,"Forward",7) == 0) {Forward();}
if(strncmp(ReceiveStr,"Backward",8) == 0) {Backward();}
if(strncmp(ReceiveStr,"SpinL",5) == 0) {SpinL();}
if(strncmp(ReceiveStr,"SpinR",5) == 0) {SpinR();}
if(strncmp(ReceiveStr,"TurnL",5) == 0) {TurnL();}
if(strncmp(ReceiveStr,"TurnR",5) == 0) {TurnR();}
if(strncmp(ReceiveStr,"Stop",4) == 0) {Stop();}
if(strncmp(ReceiveStr,"Tservop",7) == 0) {tservop();}
if(strncmp(ReceiveStr,"Pservop",7) == 0) {pservop();}
if(strncmp(ReceiveStr,"LGH",3) == 0) {lgh();}
if(strncmp(ReceiveStr,"SNR",3) == 0) {snr();}
if(strncmp(ReceiveStr,"BMP",3) == 0) {bmp();}
if(strncmp(ReceiveStr,"ENC",3) == 0) {enc();}
if(strncmp(ReceiveStr,"DISABLE",7) == 0) {op = 0;}
}
uprintf("Disaled\r");
while (1) {}
}
QString DecodedText::report() // returns a string of the SNR field with a leading + or - followed by two digits
{
int sr = snr();
if (sr<-50)
sr = -50;
else
if (sr > 49)
sr = 49;
QString rpt;
rpt.sprintf("%d",abs(sr));
if (sr > 9)
rpt = "+" + rpt;
else
if (sr >= 0)
rpt = "+0" + rpt;
else
if (sr >= -9)
rpt = "-0" + rpt;
else
rpt = "-" + rpt;
return rpt;
}
int main(int argc, char const *argv[])
{
FILE*fp,*image;
unsigned char** red,**green,**blue, *image_contents_rgb, *image_contents_rgbt;
int i, ERROR;
Header1 header1;
Header2 header2;
if(argc!= 2)
{
/* syntax error check*/
printf("\n The format is ./quantizer [file-name]");
return -1;
}
if((fp = fopen(argv[1],"rb"))== NULL)
{
/* open the .bmp file for reading*/
printf("\n Error opening the file specified. Please check if the file exists !!\n");
fclose(fp);
return -1;
}
if(fread(&header1,sizeof(header1),1,fp)!=1)
{
/* Read the primary header from the bmp file */
printf("\n Error reading header1 \n");
fclose(fp);
return -1;
}
if(header1.type!= 19778)
{
/* check if its a valid bmp file*/
printf("\n Not a bmp file. Exiting !! \n");
fclose(fp);
return -1;
}
if(fread(&header2,sizeof(header2),1,fp)!=1 )
{
printf("\n Error reading header 2");
fclose(fp);
return -1;
}
image_contents_rgb = (unsigned char*)malloc(sizeof(char) * header2.imagesize);
image_contents_rgbt = (unsigned char*)malloc(sizeof(char) * header2.imagesize); /*allocate memory to store image data*/
fseek(fp,header1.offset,SEEK_SET);
if((ERROR=fread(image_contents_rgb,header2.imagesize,1,fp))!=1)
{
printf("\nError reading contents\n");
free(image_contents_rgb);
fclose(fp);
return -1;
}
fclose(fp);
red = (unsigned char**)malloc(sizeof(char*) * header2.height);
green = (unsigned char**)malloc(sizeof(char*) * header2.height);
blue = (unsigned char**)malloc(sizeof(char*) * header2.height);
for(i=0 ; i<header2.height ;i++)
{
red[i] = (unsigned char*)malloc( sizeof(char) * header2.width);
green[i]= (unsigned char*)malloc( sizeof(char) * header2.width);
blue[i]= (unsigned char*)malloc( sizeof(char) * header2.width);
}
vector2matrix(red,green,blue,image_contents_rgb,header2.height,header2.width); /* call to store image contents as matrix */
matrix2vector_rgb(red,green,blue,image_contents_rgbt,header2.height,header2.width); /*convert back from matrix to vector*/
snr(image_contents_rgb, image_contents_rgbt, header2.height, header2.width); /* Calulate PSNR*/
if((image = fopen("quant_image","wb")) == NULL)
{
printf("\n ERROR opening the file to write quantized image !!\n");
fclose(image);
return -1;
}
if(fwrite(&header1,sizeof(header1),1,image)!= 1)
{
printf("\n ERROR writing header 1 into destination file !!\n");
fclose(image);
return -1;
}
if(fwrite(&header2,sizeof(header2),1,image)!= 1)
{
printf("\n ERROR writing header 2 into destination file !! \n");
fclose(image);
return -1;
}
fseek(image, header1.offset, SEEK_SET);
if(fwrite(image_contents_rgbt,header2.imagesize,1,image)!=1)
{
/*Store the edited RGB components into a bmp file*/
printf("\n ERROR writing image contents into destination file \n");
fclose(image);
return -1;
}
free(red);
free(green);
free(blue);
free(image_contents_rgb);
fclose(image);
return 0;
}
void Server::run()
{
Packet * pPacket = NULL, * pNewPacket = NULL;
unsigned char * pNewMessage;
int iNewMessageLength = 0;
in_addr_t ipTX;
std::map<in_addr_t, in_addr_t> mapNewCars;
struct timeval tWait = MakeTime(SERVER_WAIT_SECS, SERVER_WAIT_USECS);
std::map<in_addr_t, std::vector<Packet *> >::iterator iterPackets;
std::map<in_addr_t, Buffer>::iterator iterBuffer;
std::map<in_addr_t, CarModel *> * pCarRegistry;
std::map<in_addr_t, InfrastructureNodeModel *> * pNodeRegistry;
std::map<in_addr_t, CarModel *>::iterator iterCarReceiver;
std::map<in_addr_t, InfrastructureNodeModel *>::iterator iterNode;
struct timeval tRX;
char iRSSI, iSNR;
fd_set rfds;
std::list<ReadBuffer> listRead;
std::list<ReadBuffer>::iterator iterRead;
while (!m_bCancelled)
{
// get any waiting messages
m_mutexConnections.lock();
if (FillFDs(&rfds) && Select(&rfds, tWait))
{
Read(&rfds, listRead);
for (iterRead = listRead.begin(); iterRead != listRead.end(); ++iterRead)
{
ipTX = ntohl(iterRead->sFrom.sin_addr.s_addr);
// if new message is not null, add it to the current buffer
if (iterRead->pData != NULL)
m_mapBuffers[ipTX] += Buffer(iterRead->pData, iterRead->iLength);
}
listRead.clear();
}
m_mutexConnections.unlock();
// process non-empty buffers into messages
for (iterBuffer = m_mapBuffers.begin(); iterBuffer != m_mapBuffers.end(); ++iterBuffer)
{
if (iterBuffer->second.m_iLength > 0)
{
//printf("processing buffer..........\n");
//fflush(stdout);
unsigned char * pNew = NULL;
pCarRegistry = g_pCarRegistry->acquireLock();
pNodeRegistry = g_pInfrastructureNodeRegistry->acquireLock();
m_mutexBuffers.lock();
pNewMessage = iterBuffer->second.m_pData;
iNewMessageLength = (signed)iterBuffer->second.m_iLength;
tRX = GetCurrentTime();
iRSSI = rssi();
iSNR = snr();
while (iNewMessageLength >= (signed)PACKET_MINIMUM_LENGTH && (pPacket = CreatePacket(*(const PacketType *)pNewMessage)) != NULL) {
//printf("got packet...\n");
if (!pPacket->FromBytes(pNewMessage, iNewMessageLength))
{
//printf("failed...\n");
DestroyPacket(pPacket);
iNewMessageLength = 0;
break;
}
//if(((SafetyPacket*)pPacket)->m_ePacketType == ptSafety)
// printf("data: %s\n", ((SafetyPacket*)pPacket)->m_pData);
//if(((Packet*)pPacket)->m_ePacketType == ptGeneric)
// printf("long: %ld\n", ((Packet*)pPacket)->m_ptTXPosition.m_iLong);
// add it to the proper message buffer
pPacket->m_tRX = tRX;
pPacket->m_iRSSI = iRSSI;
pPacket->m_iSNR = iSNR;
pNewPacket = pPacket->clone();
for (iterCarReceiver = pCarRegistry->begin(); iterCarReceiver != pCarRegistry->end(); ++iterCarReceiver)
{
if (iterCarReceiver->second != NULL && iterCarReceiver->second->GetOwnerIPAddress() == CARMODEL_IPOWNER_LOCAL && iterCarReceiver->first != pPacket->m_ipTX) {
pNewPacket->m_ipRX = iterCarReceiver->first;
iterCarReceiver->second->ReceivePacket(pNewPacket);
}
}
for (iterNode = pNodeRegistry->begin(); iterNode != pNodeRegistry->end(); ++iterNode)
{
if (iterNode->second != NULL && iterNode->first != pPacket->m_ipTX)
{
pNewPacket->m_ipRX = iterNode->first;
iterNode->second->ReceivePacket(pNewPacket);
}
}
DestroyPacket(pNewPacket);
iterCarReceiver = pCarRegistry->find(pPacket->m_ID.srcID.ipCar);
iterNode = pNodeRegistry->find(pPacket->m_ID.srcID.ipCar);
if ((iterCarReceiver == pCarRegistry->end() || iterCarReceiver->second == NULL || iterCarReceiver->second->GetOwnerIPAddress() != CARMODEL_IPOWNER_LOCAL) && (iterNode == pNodeRegistry->end() || iterNode->second == NULL))
{
//printf("processing..................................\n");
mapNewCars[pPacket->m_ID.srcID.ipCar] = iterBuffer->first;
iterPackets = m_mapPackets.find(pPacket->m_ID.srcID.ipCar);
if (iterPackets == m_mapPackets.end())
iterPackets = m_mapPackets.insert(std::pair<in_addr_t, std::vector<Packet *> >(pPacket->m_ID.srcID.ipCar, std::vector<Packet *>())).first;
iterPackets->second.push_back(pPacket);
push_heap(iterPackets->second.begin(), iterPackets->second.end(), ComparePacketPtrs);
}
else
DestroyPacket(pPacket);
}
m_mutexBuffers.unlock();
g_pInfrastructureNodeRegistry->releaseLock();
g_pCarRegistry->releaseLock();
if (iNewMessageLength > 0)
pNew = (unsigned char *)memcpy(malloc(iNewMessageLength), pNewMessage, iNewMessageLength);
iterBuffer->second = Buffer(pNew, iNewMessageLength);
}
}
//add new network car to list
if (!mapNewCars.empty()) {
g_pSimulator->m_ModelMgr.AddNetworkCars(mapNewCars);
mapNewCars.clear();
}
//sleep(1);
}
}
