text stringlengths 1 24.5M |
|---|
//
// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
enum class TargetEndianness
{
BeWire,
LeWire
}; |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
namespace arm
{
namespace pipe
{
int GetCurrentThreadId();
} // namespace pipe
} // namespace arm
|
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
// This header brings in the Win32 API header, with some small modifications applied to prevent clashes with our code.
#if defined(_MSC_VER)
#define NOMINMAX // Prevent definition of min/max macros that inter... |
//
// Copyright © 2017 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "CommandHandlerFunctor.hpp"
namespace arm
{
namespace pipe
{
uint32_t CommandHandlerFunctor::GetFamilyId() const
{
return m_FamilyId;
}
uint32_t CommandHandlerFunctor::GetPacketId() const
{
re... |
//
// Copyright © 2017 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "CommandHandlerKey.hpp"
namespace arm
{
namespace pipe
{
uint32_t CommandHandlerKey::GetFamilyId() const
{
return m_FamilyId;
}
uint32_t CommandHandlerKey::GetPacketId() const
{
return m_Packe... |
//
// Copyright © 2017 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <common/include/Assert.hpp>
#include <common/include/CommandHandlerRegistry.hpp>
#include <sstream>
namespace arm
{
namespace pipe
{
void CommandHandlerRegistry::RegisterFunctor(CommandHandlerFunctor... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <common/include/Assert.hpp>
#include <common/include/CommonProfilingUtils.hpp>
#include <common/include/ProfilingException.hpp>
#include <iostream>
#include <limits>
#include <sstream>
namespace arm
{
... |
//
// Copyright © 2017 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <common/include/CounterDirectory.hpp>
#include <common/include/CommonProfilingUtils.hpp>
#include <common/include/Assert.hpp>
#include <common/include/SwTrace.hpp>
#include <fmt/format.h>
namespace arm... |
//
// Copyright © 2019 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "LabelsAndEventClasses.hpp"
namespace arm
{
namespace pipe
{
ProfilingGuidGenerator LabelsAndEventClasses::m_GuidGenerator;
// Labels (string value + GUID)
std::string LabelsAndEventClasses::EMPTY_LAB... |
//
// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <common/include/Logging.hpp>
#include <common/include/IgnoreUnused.hpp>
#include <common/include/Assert.hpp>
#if defined(_MSC_VER)
#include <common/include/WindowsWrapper.hpp>
#endif
#if defined(__ANDRO... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#if !defined(ARMNN_DISABLE_SOCKETS)
#include <common/include/NetworkSockets.hpp>
#if defined(__unix__) || defined(__APPLE__)
#include <unistd.h>
#include <fcntl.h>
#endif
#include <common/include/Conversion.hpp... |
//
// Copyright © 2017 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <common/include/PacketVersionResolver.hpp>
namespace arm
{
namespace pipe
{
bool PacketKey::operator<(const PacketKey& rhs) const
{
bool result = true;
if (m_FamilyId == rhs.m_FamilyId)
{
... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "Processes.hpp"
#if defined(__unix__) || defined(__APPLE__)
#include <unistd.h>
#elif defined(_MSC_VER)
#include <common/include/WindowsWrapper.hpp>
#endif
namespace arm
{
namespace pipe
{
int GetCurre... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <common/include/CommonProfilingUtils.hpp>
#include <common/include/NumericCast.hpp>
#include <common/include/ProfilingException.hpp>
#include <common/include/SwTrace.hpp>
#include <sstream>
namespace ar... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "Threads.hpp"
#if defined(__linux__)
#include <unistd.h>
#include <sys/syscall.h>
#define gettid() syscall(SYS_gettid)
#elif defined(_MSC_VER)
#include <common/include/WindowsWrapper.hpp>
#elif defined(_... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <common/include/NetworkSockets.hpp>
#include <common/include/Packet.hpp>
#include <common/include/SocketConnectionException.hpp>
#include <common/include/TargetEndianess.hpp>
#include <stri... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "BasePipeServer.hpp"
#include <string>
namespace arm
{
namespace pipe
{
class ConnectionHandler
{
public:
/// Constructor establishes the Unix domain socket and sets it to listen for ... |
//
// Copyright © 2019 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <common/include/CommandHandlerFunctor.hpp>
#include <common/include/CounterDirectory.hpp>
#include <atomic>
namespace arm
{
namespace pipe
{
struct CounterDirectoryEventRecord
{
uint... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <cstdint>
#include <string>
namespace arm
{
namespace pipe
{
class ITimelineDecoder
{
public:
enum class TimelineStatus
{
TimelineStatus_Success,
TimelineStatus_... |
//
// Copyright © 2019 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "ITimelineDecoder.hpp"
#include <common/include/CommandHandlerFunctor.hpp>
#include <common/include/Packet.hpp>
namespace arm
{
namespace pipe
{
class TimelineCaptureCommandHandler : pub... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "ITimelineDecoder.hpp"
#include <mutex>
#include <utility>
#include <vector>
namespace arm
{
namespace pipe
{
class TimelineDecoder : public ITimelineDecoder
{
public:
struct Model
... |
//
// Copyright © 2019 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "TimelineCaptureCommandHandler.hpp"
#include <common/include/SwTrace.hpp>
namespace arm
{
namespace pipe
{
class TimelineDirectoryCaptureCommandHandler : public arm::pipe::CommandHandler... |
//
// Copyright © 2020, 2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <server/include/basePipeServer/BasePipeServer.hpp>
#include <common/include/Constants.hpp>
#include <common/include/NumericCast.hpp>
#include <iostream>
#include <vector>
#include <iomanip>
#inclu... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <server/include/basePipeServer/ConnectionHandler.hpp>
#include <string>
namespace arm
{
namespace pipe
{
ConnectionHandler::ConnectionHandler(const std::string& udsNamespace, const bool setNonBlocking... |
//
// Copyright © 2020, 2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <server/include/basePipeServer/ConnectionHandler.hpp>
#include <client/src/BufferManager.hpp>
#include <client/src/SendCounterPacket.hpp>
#include <client/src/SocketProfilingConnection.hpp>
#inclu... |
//
// Copyright © 2019 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <common/include/CommonProfilingUtils.hpp>
#include <server/include/timelineDecoder/DirectoryCaptureCommandHandler.hpp>
#include <atomic>
#include <iostream>
namespace arm
{
namespace pipe
{
// Utils
... |
//
// Copyright © 2019 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <common/include/CommonProfilingUtils.hpp>
#include <common/include/Logging.hpp>
#include <server/include/timelineDecoder/TimelineCaptureCommandHandler.hpp>
#include <string>
namespace arm
{
namespace p... |
//
// Copyright © 2019 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <common/include/CommonProfilingUtils.hpp>
#include <server/include/timelineDecoder/TimelineDecoder.hpp>
#include <iostream>
#include <sstream>
namespace arm
{
namespace pipe
{
TimelineDecoder::Timeline... |
//
// Copyright © 2019 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <common/include/CommonProfilingUtils.hpp>
#include <common/include/SwTrace.hpp>
#include <server/include/timelineDecoder/TimelineCaptureCommandHandler.hpp>
#include <server/include/timelineDecoder/Timelin... |
//
// Copyright © 2019 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <common/include/CommandHandlerFunctor.hpp>
#include <common/include/CommonProfilingUtils.hpp>
#include <common/include/Threads.hpp>
#include <server/include/timelineDecoder/TimelineCaptureCommandHandler.h... |
//
// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <cstdio>
int main()
{
printf("The bare metal deserialized graph was successfully executed\n");
return 0;
}
|
//
// Copyright © 2021, 2023-2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <armnn/ArmNN.hpp>
#include <armnn/backends/ICustomAllocator.hpp>
#include <arm_compute/core/CL/CLKernelLibrary.h>
#include <arm_compute/runtime/CL/CLScheduler.h>
#include <iostream>
/** Samp... |
//
// Copyright © 2020-2021,2023 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <armnn/INetwork.hpp>
#include <armnn/IRuntime.hpp>
#include <armnn/Utils.hpp>
#include <armnn/Descriptors.hpp>
#include <iostream>
/// A simple example of using the ArmNN SDK API with the stand... |
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <armnn/INetwork.hpp>
#include <armnn/IRuntime.hpp>
#include <armnn/Utils.hpp>
#include <armnn/Descriptors.hpp>
#include <iostream>
/// A simple example of using the ArmNN SDK API. In this sample, the users single input n... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "Types.hpp"
#include "armnn/ArmNN.hpp"
#include "armnnTfLiteParser/ITfLiteParser.hpp"
#include "armnnUtils/DataLayoutIndexed.hpp"
#include <armnn/Logging.hpp>
#include "Profiling.hpp"
#inc... |
//
// Copyright © 2021 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <string>
#include <iostream>
#include <cmath>
#include <vector>
#include <exception>
#include "SlidingWindow.hpp"
namespace audio
{
/**
* @brief Class used to capture the audio data loade... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <stdio.h>
#include <iterator>
/**
* Class Array2d is a data structure that represents a two dimensional array.
* The data is allocated in contiguous memory, arranged row-wise
* and indivi... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <vector>
#include <cmath>
#include <cstdint>
#include <numeric>
class MathUtils
{
public:
/**
* @brief Computes the FFT for the input vector
* @param[in] input Floating poin... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <vector>
#include <cstdint>
#include <cmath>
#include <limits>
#include <string>
/* MFCC's consolidated parameters */
class MfccParams
{
public:
float m_samplingFreq;
int ... |
//
// Copyright © 2021 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
template<class T>
class SlidingWindow
{
protected:
T* m_start = nullptr;
size_t m_dataSize = 0;
size_t m_size = 0;
size_t m_stride = 0;
size_t m_count = 0;
public:
/**
*... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "IFrameOutput.hpp"
#include <opencv2/opencv.hpp>
namespace common
{
class CvVideoFileWriter : public IFrameOutput<cv::Mat> {
public:
/**
* @brief Default constructor.
*
... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "IFrameReader.hpp"
#include <opencv2/opencv.hpp>
namespace common
{
class CvVideoFrameReader :
public IFrameReader<cv::Mat>
{
public:
/**
* @brief Default constructor.
*
... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "IFrameOutput.hpp"
#include <opencv2/opencv.hpp>
namespace common
{
class CvWindowOutput : public IFrameOutput<cv::Mat> {
public:
CvWindowOutput() = default;
~CvWindowOutput() ov... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <cstddef>
#include <memory>
namespace common
{
/**
* @brief Frames output interface
*
* @tparam FrameDataT frame container data type
*/
template<typename FrameDataT> class IFrameOut... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <cstddef>
#include <memory>
namespace common
{
/**
* @brief Frame source reader interface
*
* @tparam FrameDataT frame container data type
*/
template<typename FrameDataT> class IFrameR... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <string>
#include <map>
/*
* Checks that a particular option was specified by the user
*/
bool CheckOptionSpecified(const std::map<std::string, std::string>& options, const std::string& opt... |
//
// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <chrono>
#include <iostream>
#include <string>
using namespace std::chrono;
namespace common
{
/**
* @brief Used for meausuring performance of specific actions in the code.
* Profiling sho... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <cstddef>
#include <cstdint>
#include <vector>
#include <tuple>
#include <armnn/BackendId.hpp>
namespace common
{
struct Size
{
uint32_t m_Width;
uint32_t m_Height;
Size() :... |
//
// Copyright © 2021 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "AudioCapture.hpp"
#include <alsa/asoundlib.h>
#include <sndfile.h>
#include <samplerate.h>
namespace audio
{
std::vector<float> AudioCapture::LoadAudioFile(std::string filePath)
{
SF_INF... |
//
// Copyright © 2021 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "MathUtils.hpp"
#include <vector>
#include <cmath>
#include <cstdio>
void MathUtils::FftF32(std::vector<float>& input,
std::vector<float>& fftOutput)
{
const int inputLength = ... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "MFCC.hpp"
#include "MathUtils.hpp"
#include <cfloat>
#include <cinttypes>
#include <cstring>
MfccParams::MfccParams(
const float samplingFreq,
const int numFbankBins,
const float... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "CvVideoFileWriter.hpp"
namespace common
{
void CvVideoFileWriter::Init(const std::string& outputVideo, int encoding, double fps, int width, int height)
{
m_ready = m_cvWriter.open(outputVideo, cv::... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "CvVideoFrameReader.hpp"
namespace common
{
std::shared_ptr<cv::Mat> CvVideoFrameReader::ReadFrame()
{
// opencv copies data anyway
cv::Mat captureFrame;
m_capture.read(captureFrame);
r... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "CvWindowOutput.hpp"
namespace common
{
void CvWindowOutput::Init(const std::string& windowName)
{
m_windowName = windowName;
cv::namedWindow(m_windowName, cv::WINDOW_AUTOSIZE);
}
void CvWindow... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "CmdArgsParser.hpp"
#include <iostream>
/*
* Checks that a particular option was specified by the user
*/
bool CheckOptionSpecified(const std::map<std::string, std::string>& options, const std::string& ... |
//
// Copyright © 2021 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#define CATCH_CONFIG_MAIN
#include <catch.hpp>
#include <limits>
#include "AudioCapture.hpp"
TEST_CASE("Test capture of audio file")
{
std::string testResources = TEST_RESOURCE_DIR;
REQUIRE(testResources... |
//
// Copyright © 2021 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <catch.hpp>
#include <limits>
#include "MathUtils.hpp"
#include <iostream>
#include <numeric>
TEST_CASE("Test DotProductF32")
{
// Test Constants:
const int length = 6;
float inputA[] = { ... |
//
// Copyright © 2021 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
# pragma once
#include <string>
#include <map>
#include "ArmnnNetworkExecutor.hpp"
namespace kws
{
/**
* @brief Decodes quantised last layer of model output
*
*/
class Decoder
{
private:
int quantisationOf... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "MFCC.hpp"
/* Class to provide DS-CNN specific MFCC calculation requirements. */
class DsCnnMFCC : public MFCC
{
public:
explicit DsCnnMFCC(MfccParams& params)
: MFCC(params)... |
//
// Copyright © 2021 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#ifndef KEYWORD_SPOTTING_EXAMPLE_DSCNNPREPROCESSOR_HPP
#define KEYWORD_SPOTTING_EXAMPLE_DSCNNPREPROCESSOR_HPP
#include <numeric>
#include "DsCnnMfcc.hpp"
namespace kws
{
class DsCNNPreprocessor
{
public:
DsC... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "ArmnnNetworkExecutor.hpp"
#include "Decoder.hpp"
#include "MFCC.hpp"
#include "DsCNNPreprocessor.hpp"
namespace kws
{
/**
* Generic Keyword Spotting pipeline with 3 steps: data pre-proces... |
//
// Copyright © 2021 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "Decoder.hpp"
std::pair<int, float> kws::Decoder::decodeOutput(std::vector<int8_t>& modelOutput)
{
std::vector<float> dequantisedOutput;
//Normalise vector values into new vector
for (auto&... |
//
// Copyright © 2021 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <cmath>
#include <numeric>
#include <algorithm>
#include <memory>
#include "MathUtils.hpp"
#include "SlidingWindow.hpp"
#include "DsCNNPreprocessor.hpp"
std::vector<int8_t> kws::DsCNNPreprocessor::Invoke(... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "KeywordSpottingPipeline.hpp"
#include "ArmnnNetworkExecutor.hpp"
#include "DsCNNPreprocessor.hpp"
namespace kws
{
KWSPipeline::KWSPipeline(std::unique_ptr<common::ArmnnNetworkExecutor<int8_t>> executor,... |
//
// Copyright © 2021 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <iostream>
#include <map>
#include <vector>
#include <algorithm>
#include <cmath>
#include "KeywordSpottingPipeline.hpp"
#include "CmdArgsParser.hpp"
#include "ArmnnNetworkExecutor.hpp"
#include "AudioCapt... |
//
// Copyright © 2021 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <catch.hpp>
#include <map>
#include "Decoder.hpp"
TEST_CASE("Test KWS decoder")
{
// Actual output probability: [0.0, 0.06, 0.02, 0.03, 0.0, 0.0, 0.05, 0.0, 0.83, 0.0, 0.1, 0.0]
// int8 quantised ... |
//
// Copyright © 2021 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <catch.hpp>
#include <map>
#include <cinttypes>
#include "KeywordSpottingPipeline.hpp"
#include "DsCNNPreprocessor.hpp"
static std::string GetResourceFilePath(const std::string& filename)
{
std::stri... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
namespace od
{
/**
* @brief Class used to store and receive bounding box location and size information
*
*/
class BoundingBox
{
public:
/**
* @brief Default constructor
*/
BoundingBox... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "BoundingBox.hpp"
#include <string>
#include <vector>
namespace od
{
/**
* An object detection network inference result decoded data representation.
*/
class DetectedObject
{
public:
... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "DetectedObject.hpp"
#include "Types.hpp"
#include <vector>
namespace od
{
class IDetectionResultDecoder
{
public:
/**
* @brief Returns decoded detected objects from a network ... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "DetectedObject.hpp"
#include "Types.hpp"
#include <opencv2/opencv.hpp>
#include <vector>
const cv::InterpolationFlags DefaultResizeFlag = cv::INTER_NEAREST;
/**
* @brief Function to proc... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "DetectedObject.hpp"
#include <numeric>
#include <vector>
namespace od
{
/**
* @brief Returns a vector of indices corresponding to input detections kept after NMS.
*
* Perform non max supp... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "ArmnnNetworkExecutor.hpp"
#include "YoloResultDecoder.hpp"
#include "SSDResultDecoder.hpp"
# include "ImageUtils.hpp"
#include <opencv2/opencv.hpp>
namespace od
{
/**
* Generic object de... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "Types.hpp"
#include "DetectedObject.hpp"
#include "IDetectionResultDecoder.hpp"
namespace od
{
class SSDResultDecoder : public IDetectionResultDecoder
{
public:
/**
* Constructs M... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "Types.hpp"
#include "ArmnnNetworkExecutor.hpp"
#include "DetectedObject.hpp"
#include "IDetectionResultDecoder.hpp"
#include "NonMaxSuppression.hpp"
namespace od
{
class YoloResultDecoder ... |
//
// Copyright © 2022, 2023 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "Types.hpp"
#include "armnn/ArmNN.hpp"
#include <armnn/Logging.hpp>
#include <armnn_delegate.hpp>
#include <DelegateOptions.hpp>
#include <DelegateUtils.hpp>
#include <Profiling.hpp>
... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "BoundingBox.hpp"
#include <algorithm>
namespace od
{
BoundingBox::BoundingBox() :
BoundingBox(0, 0, 0u, 0u) {}
BoundingBox::BoundingBox(
int x,
int y,
unsigned int width... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "DetectedObject.hpp"
namespace od
{
DetectedObject::DetectedObject() :
DetectedObject(0u, "", BoundingBox(), 0u)
{}
DetectedObject::DetectedObject(
unsigned int id,
std::string ... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "ImageUtils.hpp"
#include "BoundingBox.hpp"
#include "Types.hpp"
#include <armnn/Logging.hpp>
static cv::Scalar GetScalarColorCode(std::tuple<int, int, int> color)
{
return cv::Scalar(std::get<0>(co... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "CvVideoFrameReader.hpp"
#include "CvWindowOutput.hpp"
#include "CvVideoFileWriter.hpp"
#include "ObjectDetectionPipeline.hpp"
#include "CmdArgsParser.hpp"
#include <fstream>
#include <iostream>
#include... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "NonMaxSuppression.hpp"
#include <algorithm>
namespace od
{
static std::vector<unsigned int> GenerateRangeK(unsigned int k)
{
std::vector<unsigned int> range(k);
std::iota(range.begin(), range.e... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "ObjectDetectionPipeline.hpp"
#include "ImageUtils.hpp"
namespace od
{
ObjDetectionPipeline::ObjDetectionPipeline(std::unique_ptr<common::ArmnnNetworkExecutor<float>> executor,
... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "SSDResultDecoder.hpp"
#include <cassert>
#include <algorithm>
#include <cmath>
#include <stdexcept>
namespace od
{
DetectedObjects SSDResultDecoder::Decode(const common::InferenceResults<float>& networ... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "YoloResultDecoder.hpp"
#include "NonMaxSuppression.hpp"
#include <cassert>
#include <stdexcept>
namespace od
{
DetectedObjects YoloResultDecoder::Decode(const common::InferenceResults<float>& network... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <catch.hpp>
#include "BoundingBox.hpp"
namespace
{
static constexpr unsigned int s_X = 100u;
static constexpr unsigned int s_Y = 200u;
static constexpr unsigned int s_W = 300u;
static con... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#define CATCH_CONFIG_MAIN
#include <catch.hpp>
#include <opencv2/opencv.hpp>
#include "IFrameReader.hpp"
#include "CvVideoFrameReader.hpp"
SCENARIO("Read frames from video file using CV frame reader", "[framere... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <catch.hpp>
#include <opencv2/opencv.hpp>
#include "ImageUtils.hpp"
#include "Types.hpp"
std::vector<std::tuple<int, int>> GetBoundingBoxPoints(std::vector<od::DetectedObject>& decodedResults,
... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <catch.hpp>
#include "NonMaxSuppression.hpp"
TEST_CASE("Non_Max_Suppression_1")
{
// Box with iou exactly 0.5.
od::DetectedObject detectedObject1;
detectedObject1.SetLabel("2");
detected... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <catch.hpp>
#include <opencv2/opencv.hpp>
#include "ObjectDetectionPipeline.hpp"
#include "Types.hpp"
static std::string GetResourceFilePath(const std::string& filename)
{
std::string testResources = ... |
//
// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <catch.hpp>
#include <opencv2/opencv.hpp>
#include "ArmnnNetworkExecutor.hpp"
#include "Types.hpp"
#include "ImageUtils.hpp"
#include "SSDResultDecoder.hpp"
#include "YoloResultDecoder.hpp"
using namespac... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <string>
#include <map>
#include <vector>
#include <algorithm>
#include <cmath>
# pragma once
namespace asr
{
/**
* @brief Class used to Decode the output of the ASR inference
*
*/
class Decoder
... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "ArmnnNetworkExecutor.hpp"
#include "Decoder.hpp"
#include "MFCC.hpp"
#include "Wav2LetterPreprocessor.hpp"
namespace asr
{
/**
* Generic Speech Recognition pipeline with 3 steps: data pr... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include "MFCC.hpp"
/* Class to provide Wav2Letter specific MFCC calculation requirements. */
class Wav2LetterMFCC : public MFCC
{
public:
explicit Wav2LetterMFCC(const MfccParams& params)
... |
//
// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#ifndef SPEECH_RECOGNITION_EXAMPLE_WAV2LETTERPREPROCESSOR_HPP
#define SPEECH_RECOGNITION_EXAMPLE_WAV2LETTERPREPROCESSOR_HPP
#include <numeric>
#include "DataStructures.hpp"
#include "SlidingWindow.hpp"
#include "M... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "Decoder.hpp"
namespace asr
{
Decoder::Decoder(std::map<int, std::string>& labels) :
m_labels(labels) {}
std::string Decoder::FilterCharacters(std::vector<char>& unfiltered)
{
std::st... |
//
// Copyright © 2021 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <iostream>
#include <map>
#include <vector>
#include <algorithm>
#include <cmath>
#include "CmdArgsParser.hpp"
#include "ArmnnNetworkExecutor.hpp"
#include "AudioCapture.hpp"
#include "SpeechRecognitionPi... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "SpeechRecognitionPipeline.hpp"
#include "ArmnnNetworkExecutor.hpp"
namespace asr
{
ASRPipeline::ASRPipeline(std::unique_ptr<common::ArmnnNetworkExecutor<int8_t>> executor,
std... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "Wav2LetterMFCC.hpp"
#include "MathUtils.hpp"
#include <cfloat>
bool Wav2LetterMFCC::ApplyMelFilterBank(
std::vector<float>& fftVec,
std::vector<std::vector<float>>& me... |
//
// Copyright © 2021 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "MathUtils.hpp"
#include <cstring>
#include <cmath>
#include <numeric>
#include <algorithm>
#include <memory>
#include "Wav2LetterPreprocessor.hpp"
#include "Wav2LetterMFCC.hpp"
float Wav2LetterPreprocess... |
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <catch.hpp>
#include <map>
#include "Decoder.hpp"
std::map<int, std::string> labels = {
{0, "a" },
{1, "b" },
{2, "c" },
{3, "d" },
{4, "e" },
{5, "f" },
... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.