#include <networkio.h>

Public Member Functions
	NetworkIO ()

void	Resize (const NetworkIO &src, int num_features)

void	Resize2d (bool int_mode, int width, int num_features)

void	ResizeFloat (const NetworkIO &src, int num_features)

void	ResizeToMap (bool int_mode, const StrideMap &stride_map, int num_features)

void	ResizeScaled (const NetworkIO &src, int x_scale, int y_scale, int num_features)

void	ResizeXTo1 (const NetworkIO &src, int num_features)

void	Zero ()

void	ZeroInvalidElements ()

void	FromPix (const StaticShape &shape, const Pix pix, TRand randomizer)

void	FromPixes (const StaticShape &shape, const std::vector< const Pix > &pixes, TRand randomizer)

void	Copy2DImage (int batch, Pix pix, float black, float contrast, TRand randomizer)

void	Copy1DGreyImage (int batch, Pix pix, float black, float contrast, TRand randomizer)

void	SetPixel (int t, int f, int pixel, float black, float contrast)

Pix *	ToPix () const

void	Print (int num) const

int	Width () const

int	NumFeatures () const

float *	f (int t)

const float *	f (int t) const

const int8_t *	i (int t) const

bool	int_mode () const

void	set_int_mode (bool is_quantized)

const StrideMap &	stride_map () const

void	set_stride_map (const StrideMap &map)

const GENERIC_2D_ARRAY< float > &	float_array () const

GENERIC_2D_ARRAY< float > *	mutable_float_array ()

void	CopyTimeStepFrom (int dest_t, const NetworkIO &src, int src_t)

void	CopyTimeStepGeneral (int dest_t, int dest_offset, int num_features, const NetworkIO &src, int src_t, int src_offset)

void	ZeroTimeStep (int t)

void	ZeroTimeStepGeneral (int t, int offset, int num_features)

void	Randomize (int t, int offset, int num_features, TRand *randomizer)

int	BestChoiceOverRange (int t_start, int t_end, int not_this, int null_ch, float rating, float certainty) const

void	ScoresOverRange (int t_start, int t_end, int choice, int null_ch, float rating, float certainty) const

int	BestLabel (int t, float *score) const

int	BestLabel (int t, int not_this, int not_that, float *score) const

int	PositionOfBestMatch (const GenericVector< int > &labels, int start, int end) const

double	ScoreOfLabels (const GenericVector< int > &labels, int start) const

void	SetActivations (int t, int label, float ok_score)

void	EnsureBestLabel (int t, int label)

bool	AnySuspiciousTruth (float confidence_thr) const

void	ReadTimeStep (int t, double *output) const

void	AddTimeStep (int t, double *inout) const

void	AddTimeStepPart (int t, int offset, int num_features, float *inout) const

void	WriteTimeStep (int t, const double *input)

void	WriteTimeStepPart (int t, int offset, int num_features, const double *input)

void	MaxpoolTimeStep (int dest_t, const NetworkIO &src, int src_t, int *max_line)

void	MaxpoolBackward (const NetworkIO &fwd, const GENERIC_2D_ARRAY< int > &maxes)

float	MinOfMaxes () const

float	Max () const

void	CombineOutputs (const NetworkIO &base_output, const NetworkIO &combiner_output)

void	ComputeCombinerDeltas (const NetworkIO &fwd_deltas, const NetworkIO &base_output)

void	CopyAll (const NetworkIO &src)

void	AddAllToFloat (const NetworkIO &src)

void	SubtractAllFromFloat (const NetworkIO &src)

void	CopyWithNormalization (const NetworkIO &src, const NetworkIO &scale)

void	ScaleFloatBy (float factor)

void	CopyWithYReversal (const NetworkIO &src)

void	CopyWithXReversal (const NetworkIO &src)

void	CopyWithXYTranspose (const NetworkIO &src)

int	CopyPacking (const NetworkIO &src, int feature_offset)

void	CopyUnpacking (const NetworkIO &src, int feature_offset, int num_features)

void	Transpose (TransposedArray *dest) const

void	ClipVector (int t, float range)

template<class Func >
void	FuncMultiply (const NetworkIO &v_io, int t, double *product)

template<class Func >
void	FuncMultiply3 (int u_t, const NetworkIO &v_io, int v_t, const double w, double product) const

template<class Func >
void	FuncMultiply3Add (const NetworkIO &v_io, int t, const double w, double product) const

template<class Func1 , class Func2 >
void	Func2Multiply3 (const NetworkIO &v_io, int t, const double w, double product) const

Static Public Member Functions
static float	ProbToCertainty (float prob)

Detailed Description

Definition at line 39 of file networkio.h.

Constructor & Destructor Documentation

◆ NetworkIO()

tesseract::NetworkIO::NetworkIO ( )

inline

Definition at line 41 of file networkio.h.

41 : int_mode_(false) {}

Member Function Documentation

◆ AddAllToFloat()

void tesseract::NetworkIO::AddAllToFloat ( const NetworkIO & src )

Definition at line 822 of file networkio.cpp.

                                                   {
   ASSERT_HOST(!int_mode_);
   ASSERT_HOST(!src.int_mode_);
   f_ += src.f_;
 }

◆ AddTimeStep()

void tesseract::NetworkIO::AddTimeStep	(	int	t,
		double *	inout
	)		const

Definition at line 618 of file networkio.cpp.

                                                       {
   int num_features = NumFeatures();
   if (int_mode_) {
     const int8_t* line = i_[t];
     for (int i = 0; i < num_features; ++i) {
       inout[i] += static_cast<double>(line[i]) / INT8_MAX;
     }
   } else {
     const float* line = f_[t];
     for (int i = 0; i < num_features; ++i) {
       inout[i] += line[i];
     }
   }
 }

◆ AddTimeStepPart()

void tesseract::NetworkIO::AddTimeStepPart	(	int	t,
		int	offset,
		int	num_features,
		float *	inout
	)		const

Definition at line 634 of file networkio.cpp.

                                                     {
   if (int_mode_) {
     const int8_t* line = i_[t] + offset;
     for (int i = 0; i < num_features; ++i) {
       inout[i] += static_cast<float>(line[i]) / INT8_MAX;
     }
   } else {
     const float* line = f_[t] + offset;
     for (int i = 0; i < num_features; ++i) {
       inout[i] += line[i];
     }
   }
 }

◆ AnySuspiciousTruth()

bool tesseract::NetworkIO::AnySuspiciousTruth ( float confidence_thr ) const

Definition at line 584 of file networkio.cpp.

                                                              {
   int num_features = NumFeatures();
   for (int t = 0; t < Width(); ++t) {
     const float* features = f_[t];
     for (int y = 0; y < num_features; ++y) {
       float grad = features[y];
       if (grad < -confidence_thr) {
         // Correcting strong output. Check for movement.
         if ((t == 0 || f_[t - 1][y] < confidence_thr / 2) &&
             (t + 1 == Width() || f_[t + 1][y] < confidence_thr / 2)) {
           return true;  // No strong positive on either side.
         }
       }
     }
   }
   return false;
 }

◆ BestChoiceOverRange()

int tesseract::NetworkIO::BestChoiceOverRange	(	int	t_start,
		int	t_end,
		int	not_this,
		int	null_ch,
		float *	rating,
		float *	certainty
	)		const

Definition at line 436 of file networkio.cpp.

                                                            {
   if (t_end <= t_start) return -1;
   int max_char = -1;
   float min_score = 0.0f;
   for (int c = 0; c < NumFeatures(); ++c) {
     if (c == not_this || c == null_ch) continue;
     ScoresOverRange(t_start, t_end, c, null_ch, rating, certainty);
     if (max_char < 0 || *rating < min_score) {
       min_score = *rating;
       max_char = c;
     }
   }
   ScoresOverRange(t_start, t_end, max_char, null_ch, rating, certainty);
   return max_char;
 }

◆ BestLabel() [1/2]

int tesseract::NetworkIO::BestLabel	(	int	t,
		float *	score
	)		const

inline

Definition at line 161 of file networkio.h.

                                            {
     return BestLabel(t, -1, -1, score);
   }

◆ BestLabel() [2/2]

int tesseract::NetworkIO::BestLabel	(	int	t,
		int	not_this,
		int	not_that,
		float *	score
	)		const

Definition at line 494 of file networkio.cpp.

                                              {
   ASSERT_HOST(!int_mode_);
   int best_index = -1;
   float best_score = -FLT_MAX;
   const float* line = f_[t];
   for (int i = 0; i < f_.dim2(); ++i) {
     if (line[i] > best_score && i != not_this && i != not_that) {
       best_score = line[i];
       best_index = i;
     }
   }
   if (score != nullptr) *score = ProbToCertainty(best_score);
   return best_index;
 }

◆ ClipVector()

void tesseract::NetworkIO::ClipVector	(	int	t,
		float	range
	)

Definition at line 976 of file networkio.cpp.

                                              {
   ASSERT_HOST(!int_mode_);
   float* v = f_[t];
   int dim = f_.dim2();
   for (int i = 0; i < dim; ++i)
     v[i] = ClipToRange<float>(v[i], -range, range);
 }

◆ CombineOutputs()

void tesseract::NetworkIO::CombineOutputs	(	const NetworkIO &	base_output,
		const NetworkIO &	combiner_output
	)

Definition at line 741 of file networkio.cpp.

                                                                  {
   int no = base_output.NumFeatures();
   ASSERT_HOST(combiner_output.NumFeatures() == no + 1);
   Resize(base_output, no);
   int width = Width();
   if (int_mode_) {
     // Number of outputs from base and final result.
     for (int t = 0; t < width; ++t) {
       int8_t* out_line = i_[t];
       const int8_t* base_line = base_output.i_[t];
       const int8_t* comb_line = combiner_output.i_[t];
       float base_weight = static_cast<float>(comb_line[no]) / INT8_MAX;
       float boost_weight = 1.0f - base_weight;
       for (int i = 0; i < no; ++i) {
         out_line[i] = IntCastRounded(base_line[i] * base_weight +
                                      comb_line[i] * boost_weight);
       }
     }
   } else {
     for (int t = 0; t < width; ++t) {
       float* out_line = f_[t];
       const float* base_line = base_output.f_[t];
       const float* comb_line = combiner_output.f_[t];
       float base_weight = comb_line[no];
       float boost_weight = 1.0f - base_weight;
       for (int i = 0; i < no; ++i) {
         out_line[i] = base_line[i] * base_weight + comb_line[i] * boost_weight;
       }
     }
   }
 }

◆ ComputeCombinerDeltas()

void tesseract::NetworkIO::ComputeCombinerDeltas	(	const NetworkIO &	fwd_deltas,
		const NetworkIO &	base_output
	)

Definition at line 775 of file networkio.cpp.

                                                                     {
   ASSERT_HOST(!int_mode_);
   // Compute the deltas for the combiner.
   int width = Width();
   int no = NumFeatures() - 1;
   ASSERT_HOST(fwd_deltas.NumFeatures() == no);
   ASSERT_HOST(base_output.NumFeatures() == no);
   // Number of outputs from base and final result.
   for (int t = 0; t < width; ++t) {
     const float* delta_line = fwd_deltas.f_[t];
     const float* base_line = base_output.f_[t];
     float* comb_line = f_[t];
     float base_weight = comb_line[no];
     float boost_weight = 1.0f - base_weight;
     float max_base_delta = 0.0;
     for (int i = 0; i < no; ++i) {
       // What did the combiner actually produce?
       float output = base_line[i] * base_weight + comb_line[i] * boost_weight;
       // Reconstruct the target from the delta.
       float comb_target = delta_line[i] + output;
       comb_line[i] = comb_target - comb_line[i];
       float base_delta = fabs(comb_target - base_line[i]);
       if (base_delta > max_base_delta) max_base_delta = base_delta;
     }
     if (max_base_delta >= 0.5) {
       // The base network got it wrong. The combiner should output the right
       // answer and 0 for the base network.
       comb_line[no] = 0.0 - base_weight;
     } else {
       // The base network was right. The combiner should flag that.
       for (int i = 0; i < no; ++i) {
         // All other targets are 0.
         if (comb_line[i] > 0.0) comb_line[i] -= 1.0;
       }
       comb_line[no] = 1.0 - base_weight;
     }
   }
 }

◆ Copy1DGreyImage()

void tesseract::NetworkIO::Copy1DGreyImage	(	int	batch,
		Pix *	pix,
		float	black,
		float	contrast,
		TRand *	randomizer
	)

Definition at line 251 of file networkio.cpp.

                                                                    {
   int width = pixGetWidth(pix);
   int height = pixGetHeight(pix);
   ASSERT_HOST(height == NumFeatures());
   int wpl = pixGetWpl(pix);
   StrideMap::Index index(stride_map_);
   index.AddOffset(batch, FD_BATCH);
   int t = index.t();
   int target_width = stride_map_.Size(FD_WIDTH);
   if (width > target_width) width = target_width;
   int x;
   for (x = 0; x < width; ++x, ++t) {
     for (int y = 0; y < height; ++y) {
       uint32_t* line = pixGetData(pix) + wpl * y;
       int pixel = GET_DATA_BYTE(line, x);
       SetPixel(t, y, pixel, black, contrast);
     }
   }
   for (; x < target_width; ++x) Randomize(t++, 0, height, randomizer);
 }

◆ Copy2DImage()

void tesseract::NetworkIO::Copy2DImage	(	int	batch,
		Pix *	pix,
		float	black,
		float	contrast,
		TRand *	randomizer
	)

Definition at line 213 of file networkio.cpp.

                                                {
   int width = pixGetWidth(pix);
   int height = pixGetHeight(pix);
   int wpl = pixGetWpl(pix);
   StrideMap::Index index(stride_map_);
   index.AddOffset(batch, FD_BATCH);
   int t = index.t();
   int target_height = stride_map_.Size(FD_HEIGHT);
   int target_width = stride_map_.Size(FD_WIDTH);
   int num_features = NumFeatures();
   bool color = num_features == 3;
   if (width > target_width) width = target_width;
   uint32_t* line = pixGetData(pix);
   for (int y = 0; y < target_height; ++y, line += wpl) {
     int x = 0;
     if (y < height) {
       for (x = 0; x < width; ++x, ++t) {
         if (color) {
           int f = 0;
           for (int c = COLOR_RED; c <= COLOR_BLUE; ++c) {
             int pixel = GET_DATA_BYTE(line + x, c);
             SetPixel(t, f++, pixel, black, contrast);
           }
         } else {
           int pixel = GET_DATA_BYTE(line, x);
           SetPixel(t, 0, pixel, black, contrast);
         }
       }
     }
     for (; x < target_width; ++x) Randomize(t++, 0, num_features, randomizer);
   }
 }

◆ CopyAll()

void tesseract::NetworkIO::CopyAll ( const NetworkIO & src )

Definition at line 816 of file networkio.cpp.

                                             {
   ASSERT_HOST(src.int_mode_ == int_mode_);
   f_ = src.f_;
 }

◆ CopyPacking()

int tesseract::NetworkIO::CopyPacking	(	const NetworkIO &	src,
		int	feature_offset
	)

Definition at line 922 of file networkio.cpp.

                                                                    {
   ASSERT_HOST(int_mode_ == src.int_mode_);
   int width = src.Width();
   ASSERT_HOST(width <= Width());
   int num_features = src.NumFeatures();
   ASSERT_HOST(num_features + feature_offset <= NumFeatures());
   if (int_mode_) {
     for (int t = 0; t < width; ++t) {
       memcpy(i_[t] + feature_offset, src.i_[t],
              num_features * sizeof(i_[t][0]));
     }
     for (int t = width; t < i_.dim1(); ++t) {
       memset(i_[t], 0, num_features * sizeof(i_[t][0]));
     }
   } else {
     for (int t = 0; t < width; ++t) {
       memcpy(f_[t] + feature_offset, src.f_[t],
              num_features * sizeof(f_[t][0]));
     }
     for (int t = width; t < f_.dim1(); ++t) {
       memset(f_[t], 0, num_features * sizeof(f_[t][0]));
     }
   }
   return num_features + feature_offset;
 }

◆ CopyTimeStepFrom()

void tesseract::NetworkIO::CopyTimeStepFrom	(	int	dest_t,
		const NetworkIO &	src,
		int	src_t
	)

Definition at line 388 of file networkio.cpp.

                                                                             {
   ASSERT_HOST(int_mode_ == src.int_mode_);
   if (int_mode_) {
     memcpy(i_[dest_t], src.i_[src_t], i_.dim2() * sizeof(i_[0][0]));
   } else {
     memcpy(f_[dest_t], src.f_[src_t], f_.dim2() * sizeof(f_[0][0]));
   }
 }

◆ CopyTimeStepGeneral()

void tesseract::NetworkIO::CopyTimeStepGeneral	(	int	dest_t,
		int	dest_offset,
		int	num_features,
		const NetworkIO &	src,
		int	src_t,
		int	src_offset
	)

Definition at line 398 of file networkio.cpp.

                                                                {
   ASSERT_HOST(int_mode_ == src.int_mode_);
   if (int_mode_) {
     memcpy(i_[dest_t] + dest_offset, src.i_[src_t] + src_offset,
            num_features * sizeof(i_[0][0]));
   } else {
     memcpy(f_[dest_t] + dest_offset, src.f_[src_t] + src_offset,
            num_features * sizeof(f_[0][0]));
   }
 }

◆ CopyUnpacking()

void tesseract::NetworkIO::CopyUnpacking	(	const NetworkIO &	src,
		int	feature_offset,
		int	num_features
	)

Definition at line 950 of file networkio.cpp.

                                                 {
   Resize(src, num_features);
   int width = src.Width();
   ASSERT_HOST(num_features + feature_offset <= src.NumFeatures());
   if (int_mode_) {
     for (int t = 0; t < width; ++t) {
       memcpy(i_[t], src.i_[t] + feature_offset,
              num_features * sizeof(i_[t][0]));
     }
   } else {
     for (int t = 0; t < width; ++t) {
       memcpy(f_[t], src.f_[t] + feature_offset,
              num_features * sizeof(f_[t][0]));
     }
   }
 }

◆ CopyWithNormalization()

void tesseract::NetworkIO::CopyWithNormalization	(	const NetworkIO &	src,
		const NetworkIO &	scale
	)

Definition at line 836 of file networkio.cpp.

                                                               {
   ASSERT_HOST(!int_mode_);
   ASSERT_HOST(!src.int_mode_);
   ASSERT_HOST(!scale.int_mode_);
   float src_max = src.f_.MaxAbs();
   ASSERT_HOST(std::isfinite(src_max));
   float scale_max = scale.f_.MaxAbs();
   ASSERT_HOST(std::isfinite(scale_max));
   if (src_max > 0.0f) {
     float factor = scale_max / src_max;
     for (int t = 0; t < src.Width(); ++t) {
       const float* src_ptr = src.f_[t];
       float* dest_ptr = f_[t];
       for (int i = 0; i < src.f_.dim2(); ++i) dest_ptr[i] = src_ptr[i] * factor;
     }
   } else {
     f_.Clear();
   }
 }

◆ CopyWithXReversal()

void tesseract::NetworkIO::CopyWithXReversal ( const NetworkIO & src )

Definition at line 877 of file networkio.cpp.

                                                       {
   int num_features = src.NumFeatures();
   Resize(src, num_features);
   StrideMap::Index b_index(src.stride_map_);
   do {
     StrideMap::Index y_index(b_index);
     do {
       StrideMap::Index fwd_index(y_index);
       StrideMap::Index rev_index(y_index);
       rev_index.AddOffset(rev_index.MaxIndexOfDim(FD_WIDTH), FD_WIDTH);
       do {
         CopyTimeStepFrom(rev_index.t(), src, fwd_index.t());
       } while (fwd_index.AddOffset(1, FD_WIDTH) &&
                rev_index.AddOffset(-1, FD_WIDTH));
     } while (y_index.AddOffset(1, FD_HEIGHT));
   } while (b_index.AddOffset(1, FD_BATCH));
 }

◆ CopyWithXYTranspose()

void tesseract::NetworkIO::CopyWithXYTranspose ( const NetworkIO & src )

Definition at line 896 of file networkio.cpp.

                                                         {
   int num_features = src.NumFeatures();
   stride_map_ = src.stride_map_;
   stride_map_.TransposeXY();
   ResizeToMap(src.int_mode(), stride_map_, num_features);
   StrideMap::Index src_b_index(src.stride_map_);
   StrideMap::Index dest_b_index(stride_map_);
   do {
     StrideMap::Index src_y_index(src_b_index);
     StrideMap::Index dest_x_index(dest_b_index);
     do {
       StrideMap::Index src_x_index(src_y_index);
       StrideMap::Index dest_y_index(dest_x_index);
       do {
         CopyTimeStepFrom(dest_y_index.t(), src, src_x_index.t());
       } while (src_x_index.AddOffset(1, FD_WIDTH) &&
                dest_y_index.AddOffset(1, FD_HEIGHT));
     } while (src_y_index.AddOffset(1, FD_HEIGHT) &&
              dest_x_index.AddOffset(1, FD_WIDTH));
   } while (src_b_index.AddOffset(1, FD_BATCH) &&
            dest_b_index.AddOffset(1, FD_BATCH));
 }

◆ CopyWithYReversal()

void tesseract::NetworkIO::CopyWithYReversal ( const NetworkIO & src )

Definition at line 858 of file networkio.cpp.

                                                       {
   int num_features = src.NumFeatures();
   Resize(src, num_features);
   StrideMap::Index b_index(src.stride_map_);
   do {
     int width = b_index.MaxIndexOfDim(FD_WIDTH) + 1;
     StrideMap::Index fwd_index(b_index);
     StrideMap::Index rev_index(b_index);
     rev_index.AddOffset(rev_index.MaxIndexOfDim(FD_HEIGHT), FD_HEIGHT);
     do {
       int fwd_t = fwd_index.t();
       int rev_t = rev_index.t();
       for (int x = 0; x < width; ++x) CopyTimeStepFrom(rev_t++, src, fwd_t++);
     } while (fwd_index.AddOffset(1, FD_HEIGHT) &&
              rev_index.AddOffset(-1, FD_HEIGHT));
   } while (b_index.AddOffset(1, FD_BATCH));
 }

◆ EnsureBestLabel()

void tesseract::NetworkIO::EnsureBestLabel	(	int	t,
		int	label
	)

Definition at line 554 of file networkio.cpp.

                                                 {
   ASSERT_HOST(!int_mode_);
   if (BestLabel(t, nullptr) != label) {
     // Output value needs enhancing. Third all the other elements and add the
     // remainder to best_label.
     int num_classes = NumFeatures();
     float* targets = f_[t];
     for (int c = 0; c < num_classes; ++c) {
       if (c == label) {
         targets[c] += (1.0 - targets[c]) * (2 / 3.0);
       } else {
         targets[c] /= 3.0;
       }
     }
   }
 }

◆ f() [1/2]

float* tesseract::NetworkIO::f ( int t )

inline

Definition at line 115 of file networkio.h.

                   {
     ASSERT_HOST(!int_mode_);
     return f_[t];
   }

◆ f() [2/2]

const float* tesseract::NetworkIO::f ( int t ) const

inline

Definition at line 119 of file networkio.h.

                               {
     ASSERT_HOST(!int_mode_);
     return f_[t];
   }

◆ float_array()

const GENERIC_2D_ARRAY<float>& tesseract::NetworkIO::float_array ( ) const

inline

Definition at line 139 of file networkio.h.

139 { return f_; }

◆ FromPix()

void tesseract::NetworkIO::FromPix	(	const StaticShape &	shape,
		const Pix *	pix,
		TRand *	randomizer
	)

Definition at line 166 of file networkio.cpp.

                                            {
   std::vector<const Pix*> pixes(1, pix);
   FromPixes(shape, pixes, randomizer);
 }

◆ FromPixes()

void tesseract::NetworkIO::FromPixes	(	const StaticShape &	shape,
		const std::vector< const Pix *> &	pixes,
		TRand *	randomizer
	)

Definition at line 175 of file networkio.cpp.

                                              {
   int target_height = shape.height();
   int target_width = shape.width();
   std::vector<std::pair<int, int>> h_w_pairs;
   for (auto pix : pixes) {
     Pix* var_pix = const_cast<Pix*>(pix);
     int width = pixGetWidth(var_pix);
     if (target_width != 0) width = target_width;
     int height = pixGetHeight(var_pix);
     if (target_height != 0) height = target_height;
     h_w_pairs.emplace_back(height, width);
   }
   stride_map_.SetStride(h_w_pairs);
   ResizeToMap(int_mode(), stride_map_, shape.depth());
   // Iterate over the images again to copy the data.
   for (size_t b = 0; b < pixes.size(); ++b) {
     Pix* pix = const_cast<Pix*>(pixes[b]);
     float black = 0.0f, white = 255.0f;
     if (shape.depth() != 3) ComputeBlackWhite(pix, &black, &white);
     float contrast = (white - black) / 2.0f;
     if (contrast <= 0.0f) contrast = 1.0f;
     if (shape.height() == 1) {
       Copy1DGreyImage(b, pix, black, contrast, randomizer);
     } else {
       Copy2DImage(b, pix, black, contrast, randomizer);
     }
   }
 }

◆ Func2Multiply3()

template<class Func1 , class Func2 >

void tesseract::NetworkIO::Func2Multiply3	(	const NetworkIO &	v_io,
		int	t,
		const double *	w,
		double *	product
	)		const

inline

Definition at line 315 of file networkio.h.

                                              {
     ASSERT_HOST(!int_mode_);
     ASSERT_HOST(!v_io.int_mode_);
     Func1 f;
     Func2 g;
     const float* u = f_[t];
     const float* v = v_io.f_[t];
     int dim = f_.dim2();
     for (int i = 0; i < dim; ++i) {
       product[i] = f(u[i]) * g(v[i]) * w[i];
     }
   }

◆ FuncMultiply()

template<class Func >

void tesseract::NetworkIO::FuncMultiply	(	const NetworkIO &	v_io,
		int	t,
		double *	product
	)

inline

Definition at line 259 of file networkio.h.

                                                                    {
     Func f;
     ASSERT_HOST(!int_mode_);
     ASSERT_HOST(!v_io.int_mode_);
     int dim = f_.dim2();
     if (int_mode_) {
       const int8_t* u = i_[t];
       const int8_t* v = v_io.i_[t];
       for (int i = 0; i < dim; ++i) {
         product[i] = f(u[i] / static_cast<double>(INT8_MAX)) * v[i] /
                      static_cast<double>(INT8_MAX);
       }
     } else {
       const float* u = f_[t];
       const float* v = v_io.f_[t];
       for (int i = 0; i < dim; ++i) {
         product[i] = f(u[i]) * v[i];
       }
     }
   }

◆ FuncMultiply3()

template<class Func >

void tesseract::NetworkIO::FuncMultiply3	(	int	u_t,
		const NetworkIO &	v_io,
		int	v_t,
		const double *	w,
		double *	product
	)		const

inline

Definition at line 283 of file networkio.h.

                                             {
     ASSERT_HOST(!int_mode_);
     ASSERT_HOST(!v_io.int_mode_);
     Func f;
     const float* u = f_[u_t];
     const float* v = v_io.f_[v_t];
     int dim = f_.dim2();
     for (int i = 0; i < dim; ++i) {
       product[i] = f(u[i]) * v[i] * w[i];
     }
   }

◆ FuncMultiply3Add()

template<class Func >

void tesseract::NetworkIO::FuncMultiply3Add	(	const NetworkIO &	v_io,
		int	t,
		const double *	w,
		double *	product
	)		const

inline

Definition at line 299 of file networkio.h.

                                                {
     ASSERT_HOST(!int_mode_);
     ASSERT_HOST(!v_io.int_mode_);
     Func f;
     const float* u = f_[t];
     const float* v = v_io.f_[t];
     int dim = f_.dim2();
     for (int i = 0; i < dim; ++i) {
       product[i] += f(u[i]) * v[i] * w[i];
     }
   }

◆ i()

const int8_t* tesseract::NetworkIO::i ( int t ) const

inline

Definition at line 123 of file networkio.h.

                                {
     ASSERT_HOST(int_mode_);
     return i_[t];
   }

◆ int_mode()

bool tesseract::NetworkIO::int_mode ( ) const

inline

Definition at line 127 of file networkio.h.

                         {
     return int_mode_;
   }

◆ Max()

float tesseract::NetworkIO::Max ( ) const

inline

Definition at line 215 of file networkio.h.

215 { return int_mode_ ? i_.Max() : f_.Max(); }

GENERIC_2D_ARRAY::Max

T Max() const

Definition: matrix.h:342

◆ MaxpoolBackward()

void tesseract::NetworkIO::MaxpoolBackward	(	const NetworkIO &	fwd,
		const GENERIC_2D_ARRAY< int > &	maxes
	)

Definition at line 700 of file networkio.cpp.

                                                                     {
   ASSERT_HOST(!int_mode_);
   Zero();
   StrideMap::Index index(fwd.stride_map_);
   do {
     int t = index.t();
     const int* max_line = maxes[t];
     const float* fwd_line = fwd.f_[t];
     int num_features = fwd.f_.dim2();
     for (int i = 0; i < num_features; ++i) {
       f_[max_line[i]][i] = fwd_line[i];
     }
   } while (index.Increment());
 }

◆ MaxpoolTimeStep()

void tesseract::NetworkIO::MaxpoolTimeStep	(	int	dest_t,
		const NetworkIO &	src,
		int	src_t,
		int *	max_line
	)

Definition at line 673 of file networkio.cpp.

                                                {
   ASSERT_HOST(int_mode_ == src.int_mode_);
   if (int_mode_) {
     int dim = i_.dim2();
     int8_t* dest_line = i_[dest_t];
     const int8_t* src_line = src.i_[src_t];
     for (int i = 0; i < dim; ++i) {
       if (dest_line[i] < src_line[i]) {
         dest_line[i] = src_line[i];
         max_line[i] = src_t;
       }
     }
   } else {
     int dim = f_.dim2();
     float* dest_line = f_[dest_t];
     const float* src_line = src.f_[src_t];
     for (int i = 0; i < dim; ++i) {
       if (dest_line[i] < src_line[i]) {
         dest_line[i] = src_line[i];
         max_line[i] = src_t;
       }
     }
   }
 }

◆ MinOfMaxes()

float tesseract::NetworkIO::MinOfMaxes ( ) const

Definition at line 717 of file networkio.cpp.

                                   {
   float min_max = 0.0f;
   int width = Width();
   int num_features = NumFeatures();
   for (int t = 0; t < width; ++t) {
     float max_value = -FLT_MAX;
     if (int_mode_) {
       const int8_t* column = i_[t];
       for (int i = 0; i < num_features; ++i) {
         if (column[i] > max_value) max_value = column[i];
       }
     } else {
       const float* column = f_[t];
       for (int i = 0; i < num_features; ++i) {
         if (column[i] > max_value) max_value = column[i];
       }
     }
     if (t == 0 || max_value < min_max) min_max = max_value;
   }
   return min_max;
 }

◆ mutable_float_array()

GENERIC_2D_ARRAY<float>* tesseract::NetworkIO::mutable_float_array ( )

inline

Definition at line 140 of file networkio.h.

140 { return &f_; }

◆ NumFeatures()

int tesseract::NetworkIO::NumFeatures ( ) const

inline

Definition at line 111 of file networkio.h.

                           {
     return int_mode_ ? i_.dim2() : f_.dim2();
   }

◆ PositionOfBestMatch()

int tesseract::NetworkIO::PositionOfBestMatch	(	const GenericVector< int > &	labels,
		int	start,
		int	end
	)		const

Definition at line 512 of file networkio.cpp.

                                                   {
   int length = labels.size();
   int last_start = end - length;
   int best_start = -1;
   double best_score = 0.0;
   for (int s = start; s <= last_start; ++s) {
     double score = ScoreOfLabels(labels, s);
     if (score > best_score || best_start < 0) {
       best_score = score;
       best_start = s;
     }
   }
   return best_start;
 }

◆ Print()

void tesseract::NetworkIO::Print ( int num ) const

Definition at line 371 of file networkio.cpp.

                                    {
   int num_features = NumFeatures();
   for (int y = 0; y < num_features; ++y) {
     for (int t = 0; t < Width(); ++t) {
       if (num == 0 || t < num || t + num >= Width()) {
         if (int_mode_) {
           tprintf(" %g", static_cast<float>(i_[t][y]) / INT8_MAX);
         } else {
           tprintf(" %g", f_[t][y]);
         }
       }
     }
     tprintf("\n");
   }
 }

◆ ProbToCertainty()

float tesseract::NetworkIO::ProbToCertainty ( float prob )

static

Definition at line 573 of file networkio.cpp.

                                            {
   return prob > kMinProb ? log(prob) : kMinCertainty;
 }

◆ Randomize()

void tesseract::NetworkIO::Randomize	(	int	t,
		int	offset,
		int	num_features,
		TRand *	randomizer
	)

Definition at line 421 of file networkio.cpp.

                                              {
   if (int_mode_) {
     int8_t* line = i_[t] + offset;
     for (int i = 0; i < num_features; ++i)
       line[i] = IntCastRounded(randomizer->SignedRand(INT8_MAX));
   } else {
     // float mode.
     float* line = f_[t] + offset;
     for (int i = 0; i < num_features; ++i)
       line[i] = randomizer->SignedRand(1.0);
   }
 }

◆ ReadTimeStep()

void tesseract::NetworkIO::ReadTimeStep	(	int	t,
		double *	output
	)		const

Definition at line 603 of file networkio.cpp.

                                                         {
   if (int_mode_) {
     const int8_t* line = i_[t];
     for (int i = 0; i < i_.dim2(); ++i) {
       output[i] = static_cast<double>(line[i]) / INT8_MAX;
     }
   } else {
     const float* line = f_[t];
     for (int i = 0; i < f_.dim2(); ++i) {
       output[i] = static_cast<double>(line[i]);
     }
   }
 }

◆ Resize()

void tesseract::NetworkIO::Resize	(	const NetworkIO &	src,
		int	num_features
	)

inline

Definition at line 45 of file networkio.h.

                                                       {
     ResizeToMap(src.int_mode(), src.stride_map(), num_features);
   }

◆ Resize2d()

void tesseract::NetworkIO::Resize2d	(	bool	int_mode,
		int	width,
		int	num_features
	)

Definition at line 40 of file networkio.cpp.

                                                                    {
   stride_map_ = StrideMap();
   int_mode_ = int_mode;
   if (int_mode_) {
     i_.ResizeNoInit(width, num_features, GetPadding(num_features));
   } else {
     f_.ResizeNoInit(width, num_features);
   }
 }

◆ ResizeFloat()

void tesseract::NetworkIO::ResizeFloat	(	const NetworkIO &	src,
		int	num_features
	)

inline

Definition at line 52 of file networkio.h.

                                                            {
     ResizeToMap(false, src.stride_map(), num_features);
   }

◆ ResizeScaled()

void tesseract::NetworkIO::ResizeScaled	(	const NetworkIO &	src,
		int	x_scale,
		int	y_scale,
		int	num_features
	)

Definition at line 67 of file networkio.cpp.

                                                                          {
   StrideMap stride_map = src.stride_map_;
   stride_map.ScaleXY(x_scale, y_scale);
   ResizeToMap(src.int_mode_, stride_map, num_features);
 }

◆ ResizeToMap()

void tesseract::NetworkIO::ResizeToMap	(	bool	int_mode,
		const StrideMap &	stride_map,
		int	num_features
	)

Definition at line 51 of file networkio.cpp.

                                               {
   // If this method crashes with this == nullptr,
   // it most likely got here through an uninitialized scratch element,
   // ie call NetworkScratch::IO::Resizexxx() not NetworkIO::Resizexxx()!!
   stride_map_ = stride_map;
   int_mode_ = int_mode;
   if (int_mode_) {
     i_.ResizeNoInit(stride_map.Width(), num_features, GetPadding(num_features));
   } else {
     f_.ResizeNoInit(stride_map.Width(), num_features);
   }
   ZeroInvalidElements();
 }

◆ ResizeXTo1()

void tesseract::NetworkIO::ResizeXTo1	(	const NetworkIO &	src,
		int	num_features
	)

Definition at line 75 of file networkio.cpp.

                                                                  {
   StrideMap stride_map = src.stride_map_;
   stride_map.ReduceWidthTo1();
   ResizeToMap(src.int_mode_, stride_map, num_features);
 }

◆ ScaleFloatBy()

void tesseract::NetworkIO::ScaleFloatBy ( float factor )

inline

Definition at line 234 of file networkio.h.

234 { f_ *= factor; }

◆ ScoreOfLabels()

double tesseract::NetworkIO::ScoreOfLabels	(	const GenericVector< int > &	labels,
		int	start
	)		const

Definition at line 530 of file networkio.cpp.

                                                  {
   int length = labels.size();
   double score = 0.0;
   for (int i = 0; i < length; ++i) {
     score += f_(start + i, labels[i]);
   }
   return score;
 }

◆ ScoresOverRange()

void tesseract::NetworkIO::ScoresOverRange	(	int	t_start,
		int	t_end,
		int	choice,
		int	null_ch,
		float *	rating,
		float *	certainty
	)		const

Definition at line 455 of file networkio.cpp.

                                                                        {
   ASSERT_HOST(!int_mode_);
   *rating = 0.0f;
   *certainty = 0.0f;
   if (t_end <= t_start || t_end <= 0) return;
   float ratings[3] = {0.0f, 0.0f, 0.0f};
   float certs[3] = {0.0f, 0.0f, 0.0f};
   for (int t = t_start; t < t_end; ++t) {
     const float* line = f_[t];
     float score = ProbToCertainty(line[choice]);
     float zero = ProbToCertainty(line[null_ch]);
     if (t == t_start) {
       ratings[2] = FLT_MAX;
       ratings[1] = -score;
       certs[1] = score;
     } else {
       for (int i = 2; i >= 1; --i) {
         if (ratings[i] > ratings[i - 1]) {
           ratings[i] = ratings[i - 1];
           certs[i] = certs[i - 1];
         }
       }
       ratings[2] -= zero;
       if (zero < certs[2]) certs[2] = zero;
       ratings[1] -= score;
       if (score < certs[1]) certs[1] = score;
     }
     ratings[0] -= zero;
     if (zero < certs[0]) certs[0] = zero;
   }
   int best_i = ratings[2] < ratings[1] ? 2 : 1;
   *rating = ratings[best_i] + t_end - t_start;
   *certainty = certs[best_i];
 }

◆ set_int_mode()

void tesseract::NetworkIO::set_int_mode ( bool is_quantized )

inline

Definition at line 130 of file networkio.h.

                                        {
     int_mode_ = is_quantized;
   }

◆ set_stride_map()

void tesseract::NetworkIO::set_stride_map ( const StrideMap & map )

inline

Definition at line 136 of file networkio.h.

                                             {
     stride_map_ = map;
   }

◆ SetActivations()

void tesseract::NetworkIO::SetActivations	(	int	t,
		int	label,
		float	ok_score
	)

Definition at line 542 of file networkio.cpp.

                                                                {
   ASSERT_HOST(!int_mode_);
   int num_classes = NumFeatures();
   float bad_score = (1.0f - ok_score) / (num_classes - 1);
   float* targets = f_[t];
   for (int i = 0; i < num_classes; ++i)
     targets[i] = bad_score;
   targets[label] = ok_score;
 }

◆ SetPixel()

void tesseract::NetworkIO::SetPixel	(	int	t,
		int	f,
		int	pixel,
		float	black,
		float	contrast
	)

Definition at line 280 of file networkio.cpp.

                                                                              {
   float float_pixel = (pixel - black) / contrast - 1.0f;
   if (int_mode_) {
     i_[t][f] = ClipToRange<int>(IntCastRounded((INT8_MAX + 1) * float_pixel),
                            -INT8_MAX, INT8_MAX);
   } else {
     f_[t][f] = float_pixel;
   }
 }

◆ stride_map()

const StrideMap& tesseract::NetworkIO::stride_map ( ) const

inline

Definition at line 133 of file networkio.h.

                                       {
     return stride_map_;
   }

◆ SubtractAllFromFloat()

void tesseract::NetworkIO::SubtractAllFromFloat ( const NetworkIO & src )

Definition at line 829 of file networkio.cpp.

                                                          {
   ASSERT_HOST(!int_mode_);
   ASSERT_HOST(!src.int_mode_);
   f_ -= src.f_;
 }

◆ ToPix()

Pix * tesseract::NetworkIO::ToPix ( ) const

Definition at line 291 of file networkio.cpp.

                             {
   // Count the width of the image, and find the max multiplication factor.
   int im_width = stride_map_.Size(FD_WIDTH);
   int im_height = stride_map_.Size(FD_HEIGHT);
   int num_features = NumFeatures();
   int feature_factor = 1;
   if (num_features == 3) {
     // Special hack for color.
     num_features = 1;
     feature_factor = 3;
   }
   Pix* pix = pixCreate(im_width, im_height * num_features, 32);
   StrideMap::Index index(stride_map_);
   do {
     int im_x = index.index(FD_WIDTH);
     int top_im_y = index.index(FD_HEIGHT);
     int im_y = top_im_y;
     int t = index.t();
     if (int_mode_) {
       const int8_t* features = i_[t];
       for (int y = 0; y < num_features; ++y, im_y += im_height) {
         int pixel = features[y * feature_factor];
         // 1 or 2 features use greyscale.
         int red = ClipToRange<int>(pixel + 128, 0, 255);
         int green = red, blue = red;
         if (feature_factor == 3) {
           // With 3 features assume RGB color.
           green = ClipToRange<int>(features[y * feature_factor + 1] + 128, 0, 255);
           blue = ClipToRange<int>(features[y * feature_factor + 2] + 128, 0, 255);
         } else if (num_features > 3) {
           // More than 3 features use false yellow/blue color, assuming a signed
           // input in the range [-1,1].
           red = abs(pixel) * 2;
           if (pixel >= 0) {
             green = red;
             blue = 0;
           } else {
             blue = red;
             green = red = 0;
           }
         }
         pixSetPixel(pix, im_x, im_y, (red << L_RED_SHIFT) |
                                          (green << L_GREEN_SHIFT) |
                                          (blue << L_BLUE_SHIFT));
       }
     } else {
       const float* features = f_[t];
       for (int y = 0; y < num_features; ++y, im_y += im_height) {
         float pixel = features[y * feature_factor];
         // 1 or 2 features use greyscale.
         int red = ClipToRange<int>(IntCastRounded((pixel + 1.0f) * 127.5f), 0, 255);
         int green = red, blue = red;
         if (feature_factor == 3) {
           // With 3 features assume RGB color.
           pixel = features[y * feature_factor + 1];
           green = ClipToRange<int>(IntCastRounded((pixel + 1.0f) * 127.5f), 0, 255);
           pixel = features[y * feature_factor + 2];
           blue = ClipToRange<int>(IntCastRounded((pixel + 1.0f) * 127.5f), 0, 255);
         } else if (num_features > 3) {
           // More than 3 features use false yellow/blue color, assuming a signed
           // input in the range [-1,1].
           red = ClipToRange<int>(IntCastRounded(fabs(pixel) * 255), 0, 255);
           if (pixel >= 0) {
             green = red;
             blue = 0;
           } else {
             blue = red;
             green = red = 0;
           }
         }
         pixSetPixel(pix, im_x, im_y, (red << L_RED_SHIFT) |
                                          (green << L_GREEN_SHIFT) |
                                          (blue << L_BLUE_SHIFT));
       }
     }
   } while (index.Increment());
   return pix;
 }

◆ Transpose()

void tesseract::NetworkIO::Transpose ( TransposedArray * dest ) const

Definition at line 969 of file networkio.cpp.

                                                      {
   int width = Width();
   dest->ResizeNoInit(NumFeatures(), width);
   for (int t = 0; t < width; ++t) dest->WriteStrided(t, f_[t]);
 }

◆ Width()

int tesseract::NetworkIO::Width ( ) const

inline

Definition at line 107 of file networkio.h.

                     {
     return int_mode_ ? i_.dim1() : f_.dim1();
   }

◆ WriteTimeStep()

void tesseract::NetworkIO::WriteTimeStep	(	int	t,
		const double *	input
	)

Definition at line 650 of file networkio.cpp.

                                                         {
   WriteTimeStepPart(t, 0, NumFeatures(), input);
 }

◆ WriteTimeStepPart()

void tesseract::NetworkIO::WriteTimeStepPart	(	int	t,
		int	offset,
		int	num_features,
		const double *	input
	)

Definition at line 656 of file networkio.cpp.

                                                        {
   if (int_mode_) {
     int8_t* line = i_[t] + offset;
     for (int i = 0; i < num_features; ++i) {
       line[i] = ClipToRange<int>(IntCastRounded(input[i] * INT8_MAX),
                                  -INT8_MAX, INT8_MAX);
     }
   } else {
     float* line = f_[t] + offset;
     for (int i = 0; i < num_features; ++i) {
       line[i] = static_cast<float>(input[i]);
     }
   }
 }

◆ Zero()

void tesseract::NetworkIO::Zero ( )

Definition at line 82 of file networkio.cpp.

                      {
   int width = Width();
   // Zero out the everything. Column-by-column in case it is aligned.
   for (int t = 0; t < width; ++t) {
     ZeroTimeStep(t);
   }
 }

◆ ZeroInvalidElements()

void tesseract::NetworkIO::ZeroInvalidElements ( )

Definition at line 93 of file networkio.cpp.

                                     {
   int num_features = NumFeatures();
   int full_width = stride_map_.Size(FD_WIDTH);
   int full_height = stride_map_.Size(FD_HEIGHT);
   StrideMap::Index b_index(stride_map_);
   do {
     int end_x = b_index.MaxIndexOfDim(FD_WIDTH) + 1;
     if (end_x < full_width) {
       // The width is small, so fill for every valid y.
       StrideMap::Index y_index(b_index);
       int fill_size = num_features * (full_width - end_x);
       do {
         StrideMap::Index z_index(y_index);
         z_index.AddOffset(end_x, FD_WIDTH);
         if (int_mode_) {
           ZeroVector(fill_size, i_[z_index.t()]);
         } else {
           ZeroVector(fill_size, f_[z_index.t()]);
         }
       } while (y_index.AddOffset(1, FD_HEIGHT));
     }
     int end_y = b_index.MaxIndexOfDim(FD_HEIGHT) + 1;
     if (end_y < full_height) {
       // The height is small, so fill in the space in one go.
       StrideMap::Index y_index(b_index);
       y_index.AddOffset(end_y, FD_HEIGHT);
       int fill_size = num_features * full_width * (full_height - end_y);
       if (int_mode_) {
         ZeroVector(fill_size, i_[y_index.t()]);
       } else {
         ZeroVector(fill_size, f_[y_index.t()]);
       }
     }
   } while (b_index.AddOffset(1, FD_BATCH));
 }

◆ ZeroTimeStep()

void tesseract::NetworkIO::ZeroTimeStep ( int t )

inline

Definition at line 148 of file networkio.h.

148 { ZeroTimeStepGeneral(t, 0, NumFeatures()); }

tesseract::NetworkIO::ZeroTimeStepGeneral

void ZeroTimeStepGeneral(int t, int offset, int num_features)

Definition: networkio.cpp:412

tesseract::NetworkIO::NumFeatures

int NumFeatures() const

Definition: networkio.h:111

◆ ZeroTimeStepGeneral()

void tesseract::NetworkIO::ZeroTimeStepGeneral	(	int	t,
		int	offset,
		int	num_features
	)

Definition at line 412 of file networkio.cpp.

                                                                        {
   if (int_mode_) {
     ZeroVector(num_features, i_[t] + offset);
   } else {
     ZeroVector(num_features, f_[t] + offset);
   }
 }

The documentation for this class was generated from the following files:

/usr/src/tesseract-ocr.master/src/lstm/networkio.h
/usr/src/tesseract-ocr.master/src/lstm/networkio.cpp

Public Member Functions

Static Public Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ NetworkIO()

Member Function Documentation

◆ AddAllToFloat()

◆ AddTimeStep()

◆ AddTimeStepPart()

◆ AnySuspiciousTruth()

◆ BestChoiceOverRange()

◆ BestLabel() [1/2]

◆ BestLabel() [2/2]

◆ ClipVector()

◆ CombineOutputs()

◆ ComputeCombinerDeltas()

◆ Copy1DGreyImage()

◆ Copy2DImage()

◆ CopyAll()

◆ CopyPacking()

◆ CopyTimeStepFrom()

◆ CopyTimeStepGeneral()

◆ CopyUnpacking()

◆ CopyWithNormalization()

◆ CopyWithXReversal()

◆ CopyWithXYTranspose()

◆ CopyWithYReversal()

◆ EnsureBestLabel()

◆ f() [1/2]

◆ f() [2/2]

◆ float_array()

◆ FromPix()

◆ FromPixes()

◆ Func2Multiply3()

◆ FuncMultiply()

◆ FuncMultiply3()

◆ FuncMultiply3Add()

◆ i()

◆ int_mode()

◆ Max()

◆ MaxpoolBackward()

◆ MaxpoolTimeStep()

◆ MinOfMaxes()

◆ mutable_float_array()

◆ NumFeatures()

◆ PositionOfBestMatch()

◆ Print()

◆ ProbToCertainty()

◆ Randomize()

◆ ReadTimeStep()

◆ Resize()

◆ Resize2d()

◆ ResizeFloat()

◆ ResizeScaled()

◆ ResizeToMap()

◆ ResizeXTo1()

◆ ScaleFloatBy()

◆ ScoreOfLabels()

◆ ScoresOverRange()

◆ set_int_mode()

◆ set_stride_map()

◆ SetActivations()

◆ SetPixel()

◆ stride_map()

◆ SubtractAllFromFloat()

◆ ToPix()

◆ Transpose()

◆ Width()

◆ WriteTimeStep()

◆ WriteTimeStepPart()

◆ Zero()

◆ ZeroInvalidElements()

◆ ZeroTimeStep()

◆ ZeroTimeStepGeneral()