Connect two lines by zigzag lines - c++

Question

I have two points on XZ plane, larger/taller point is L=(XL, ZL) and smaller/shorter point is S=(XS, ZS)
By connecting L and S points to Z=0 line, I have two lines
I intend to connect my two lines by zigzag diagonal cross lines
I need to find points L0, L1, Lk, ... LN-1 and also S0, S1, Sk, ... SN-1, SN.
I already know two points:
S0 = S = (XS, ZS)
SN = (XS, 0)
So far, I have implemented this algorithm:
float lX, lZ = ... // "L" (larger/taller) point coordinate on (X, Z) plane
float sX, sZ = ... // "S" (smaller/shorter) point coordinate on (X, Z) plane
size_t N = 5; // N sections below S
float sZsectionLength = sZ / N; // length of each section below S
std::vector<float> sZ_dots(N+1, 0.0); // N+1 points/dots below S
for (size_t k = 0; k < N+1; ++k) {
sZ_dots[k] = sZ - k * sZsectionLength;
}
std::vector<float> lZ_dots(N, 0.0); // N points/dots below L
for (size_t k = 0; k < N; ++k) {
// // Each point below L is average of two points below S
lZ_dots[k] = ( sZ_dots[k] + sZ_dots[k+1] ) / 2.0f;
}
for (size_t k = 0; k < N; ++k) {
Line *zig = new Line();
zig->setStartDot(sX, sZ_dots[k]);
zig->setCloseDot(lX, lZ_dots[k]);
linesContainer.append(zig);
Line *zag = new Line();
zag->setStartDot(lX, lZ_dots[k]);
zag->setCloseDot(sX, sZ_dots[k+1]);
linesContainer.append(zag);
}
The above algorithm generates the zig zags just fine. However, I wonder if there is any faster algorithm to generate the zig zag cross lines. Anything which I'm missing?

Answer 1

I would implement it like this:
struct Line
{
Line(float x1, float z1, float x2, float z2)
:
m_x1(x1),
m_z1(z1),
m_x2(x2),
m_z2(z2)
{}
float m_x1;
float m_z1;
float m_x2;
float m_z2;
};
using LineContainer = std::vector<Line>;
LineContainer getZigZag(float lx, float sx, float sz, size_t sectionCount)
{
assert(lx < sx && sz > 0.0f);
LineContainer lines;
auto sectionHeight = sz / sectionCount;
for (auto i = 0; i < sectionCount; ++i)
{
auto sz1 = sz - sectionHeight * i;
auto sz2 = sz - sectionHeight * (i + 1);
auto lz = sz1 - (sz1 - sz2) / 2.0f;
// A section.
//
// From S to L
lines.emplace_back(sx, sz1, lx, lz);
// From L to S
lines.emplace_back(lx, lz, sx, sz2);
}
return lines;
}
and use the function like this:
int main()
{
auto zigzag = getZigZag(1.0f, 2.0f, 4.0f, 2);
[..]
As you probably noticed, I replaced three loops with a single one that creates two lines (a single section) on each iteration.