Репликация логики подразделения кадров Veloview, что приводит к многочисленным небольшим кадрам ⇐ C++

[Anonymous]

Я работаю над пользовательским приложением, которое декодирует поток данных (PCAP или UDP -пакеты), и я изо всех сил пытаюсь воспроизвести логику подразделения кадров Veloview. Документация для интерпретатора velodyneplugin не существует, поэтому я решил обратить вспять код Lidarview . В частности, я смотрю на vtklidarreader :: getFrame и packetConsumer :: handleSensordata , и кажется, что различная логика используется для чтения из файла PCAP в зависимости от чтения из потокового источника. FrameInformation . Когда достигнут конец файла, функция vtklidarReader :: getFrame использует FrameInformation в процессе procespacketRapped для правильного декодирования каждого кадра. IsnewFrameaVailable < /code> это правда. < /P>
Однако я попытался повторить потоковую логику, и в итоге я получил многочисленные небольшие кадры.
После отладки я подозреваю, что некоторые пакеты со старым стрельбой или не прогрессивным азимутом или ценностям, перезагрузки от 0, являя межпроизводство до пкантного заканчиваемого. Должен быть дополнительная логика подразделения кадрирования, которую мне не хватает.
Может ли кто -нибудь направить меня по правильным функциям для вызова, чтобы правильно декодировать кадры при чтении из потока пакетов UDP? /> os -> Ubuntu 22.04 x64
версия -> Veloview 5.1.0 ubuntu 18.04 -x86_64
pcap -test> -> -> -> -> -> -> -> -> -> -> ->
pcap> drone_hdl32.pcap
Здесь есть применение применения для тестирования декодера (ему нужны Libpcap, VTK, Lidarview и Velodyneplugin, созданный или непосредственно Veloview, которые содержат все зависимости. />sstrong> customvelodynepacketinterpreter.h>
#ifndef CUSTOMVELODYNEPACKETINTERPRETER_H
#define CUSTOMVELODYNEPACKETINTERPRETER_H

#include "vtkVelodyneLegacyPacketInterpreter.h"

class customPacketInterpreter : public vtkVelodyneLegacyPacketInterpreter
{
public:
static customPacketInterpreter* New();
void LoadFrameData(vtkSmartPointer frame);

vtkIdType GetNumberOfPoints(vtkSmartPointer frame);
double * GetPoint(vtkIdType valueIdx, vtkSmartPointer frame);
unsigned char GetIntensity(vtkIdType valueIdx, vtkSmartPointer frame);
unsigned char GetLaserId(vtkIdType valueIdx, vtkSmartPointer frame);
unsigned short GetAzimuth(vtkIdType valueIdx, vtkSmartPointer frame);
double GetDistanceM(vtkIdType valueIdx, vtkSmartPointer frame);
unsigned long long GetAdjustedTime(vtkIdType valueIdx, vtkSmartPointer frame);
unsigned int GetTimestamp(vtkIdType valueIdx, vtkSmartPointer frame);
double GetVerticalAngle(vtkIdType valueIdx, vtkSmartPointer frame);

private:
vtkPoints* frame_points;
vtkAbstractArray* frame_intensity;
vtkAbstractArray* frame_laserId;
vtkAbstractArray* frame_azimuth;
vtkAbstractArray* frame_distance;
vtkAbstractArray* frame_adjustedTime;
vtkAbstractArray* frame_timestamp;
vtkAbstractArray* frame_verticalAngle;
};

#endif /* CUSTOMVELODYNEPACKETINTERPRETER_H */


customvelodynepacketInterpreter.cxx

#include "customVelodynePacketInterpreter.h"
#include "vtkPointData.h"

vtkStandardNewMacro(customPacketInterpreter)

void customPacketInterpreter::LoadFrameData(vtkSmartPointer frame) {
frame_points = frame->GetPoints();
auto frame_data = frame->GetPointData();
frame_intensity = frame_data->GetAbstractArray("intensity");
frame_laserId = frame_data->GetAbstractArray("laser_id");
frame_azimuth = frame_data->GetAbstractArray("azimuth");
frame_distance = frame_data->GetAbstractArray("distance_m");
frame_adjustedTime = frame_data->GetAbstractArray("adjustedtime");
frame_timestamp = frame_data->GetAbstractArray("timestamp");
frame_verticalAngle = frame_data->GetAbstractArray("vertical_angle");
}

vtkIdType customPacketInterpreter::GetNumberOfPoints(vtkSmartPointer frame) {
if (frame_points)
return frame_points->GetNumberOfPoints();
else
return frame->GetPoints()->GetNumberOfPoints();
}

double * customPacketInterpreter::GetPoint(vtkIdType valueIdx, vtkSmartPointer frame) {
if (frame_points)
return frame_points->GetPoint(valueIdx);
else
return frame->GetPoints()->GetPoint(valueIdx);
}

unsigned char customPacketInterpreter::GetIntensity(vtkIdType valueIdx, vtkSmartPointer frame) {
if (frame_intensity)
return frame_intensity->GetVariantValue(valueIdx).ToUnsignedChar();
else
return frame->GetPointData()->GetArray("intensity")->GetVariantValue(valueIdx).ToUnsignedChar();
}

unsigned char customPacketInterpreter::GetLaserId(vtkIdType valueIdx, vtkSmartPointer frame) {
if (frame_laserId)
return frame_laserId->GetVariantValue(valueIdx).ToUnsignedChar();
else
return frame->GetPointData()->GetArray("laser_id")->GetVariantValue(valueIdx).ToUnsignedChar();
}

unsigned short customPacketInterpreter::GetAzimuth(vtkIdType valueIdx, vtkSmartPointer frame) {
if (frame_azimuth)
return frame_azimuth->GetVariantValue(valueIdx).ToUnsignedShort();
else
return frame->GetPointData()->GetArray("azimuth")->GetVariantValue(valueIdx).ToUnsignedShort();
}

double customPacketInterpreter::GetDistanceM(vtkIdType valueIdx, vtkSmartPointer frame) {
if (frame_distance)
return frame_distance->GetVariantValue(valueIdx).ToDouble();
else
return frame->GetPointData()->GetArray("distance_m")->GetVariantValue(valueIdx).ToDouble();
}

unsigned long long customPacketInterpreter::GetAdjustedTime(vtkIdType valueIdx, vtkSmartPointer frame) {
if (frame_adjustedTime)
return frame_adjustedTime->GetVariantValue(valueIdx).ToUnsignedLongLong();
else
return frame->GetPointData()->GetArray("adjustedtime")->GetVariantValue(valueIdx).ToUnsignedLongLong();
}

unsigned int customPacketInterpreter::GetTimestamp(vtkIdType valueIdx, vtkSmartPointer frame) {
if (frame_timestamp)
return frame_timestamp->GetVariantValue(valueIdx).ToUnsignedInt();
else
return frame->GetPointData()->GetArray("timestamp")->GetVariantValue(valueIdx).ToUnsignedInt();
}

double customPacketInterpreter::GetVerticalAngle(vtkIdType valueIdx, vtkSmartPointer frame) {
if (frame_verticalAngle)
return frame_verticalAngle->GetVariantValue(valueIdx).ToDouble();
else
return frame->GetPointData()->GetArray("vertical_angle")->GetVariantValue(valueIdx).ToDouble();
}


main.cxx

#include
#include
#include
#include
#include
#include
#include "pcap.h"
#include "customVelodynePacketInterpreter.h"

#define PCAP_SAVEFILE "./pcap_example/Drone_HDL32.pcap"
#define CALIB_FILE "HDL-32.xml"

typedef struct s_VelodynePointData {
uint8_t laser_id;
unsigned long long timestamp;
double vertical_angle;
double x;
double y;
double z;
uint8_t intensity;
uint16_t azimuth;
double distance;
} VelodynePointData;

typedef std::vector VelodyneFrame;

pcap_t *p;
unsigned long long point_id = 0;
int frame_id = 0;
std::ofstream outfile;
std::string filename;
std::vector frameCatalog;
std::vector frameBuffer;
VelodyneFrame buildingFrame;
customPacketInterpreter *interpreter;

int usage(char *progname)
{
printf("Usage: [OPTIONS] %s []\n", progname);
printf("Options: \n");
printf("\t-h\tShows this help message.\n");
printf("\t-w\tWrite on csv files the decoded output.\n");
exit(7);
}

void print_point(const VelodynePointData& data, std::ostream& out = std::cout) {
out

Подробнее здесь: https://stackoverflow.com/questions/766 ... small-fram