Struct AdaptiveAlternatingProjection 

pub struct AdaptiveAlternatingProjection {
    pub iterations: usize,
    pub initial_object_step: f64,
    pub progress_threshold: f64,
    pub reduction_factor: f64,
    pub minimum_object_step: f64,
    pub batch_size: usize,
    pub epsilon: f64,
}

Noise-robust alternating projection with a pass-adaptive object step.

Method

The per-frame update is the same fixed-pupil amplitude projection used by super::AlternatingProjection. One relaxation factor is shared by every frame in a complete acquisition-schedule pass. The algorithm accumulates the mask-aware, frame-weighted amplitude-MSE objective already evaluated by those projections. After two completed passes establish consecutive objectives, it retains the step when relative progress is greater than progress_threshold; otherwise it multiplies the step by reduction_factor, without going below minimum_object_step.

This feedback rule does not retry or roll back an iteration. Its objective is the inexpensive incremental approximation described by Zuo et al., not an additional exact full-data evaluation. The current step, preceding objective, partial objective sums, and controller parameters are stored in ReconstructionState so a matching checkpoint resumes exactly. Batching cannot change the numerical path, while changing the acquisition schedule intentionally can.

Assumptions and limitations

The algorithm recovers only the object and keeps the compiled pupil fixed. Its feedback objective is always amplitude MSE so a reporting option cannot silently change controller behavior. It cannot be nested in physical joint calibration because recompiling the forward model changes the meaning of its objective history. The convergence analysis in the cited work assumes convex component objectives; Fourier-ptychographic phase retrieval is non-convex, so the adaptive rule is a practical robustness strategy rather than a global-convergence guarantee.

References

C. Zuo, J. Sun, and Q. Chen, “Adaptive step-size strategy for noise-robust Fourier ptychographic microscopy” (2016), Optics Express 24(18), 20724–20744.

Fields

iterations: usize

Number of complete passes through the acquisition schedule.

initial_object_step: f64

Object relaxation used until the feedback rule first reduces it.

progress_threshold: f64

Minimum relative objective decrease required to retain the current step.

reduction_factor: f64

Multiplicative step reduction used when progress is insufficient.

minimum_object_step: f64

Positive lower bound on the adaptive object step.

batch_size: usize

Number of measured frames supplied to each reconstruction step.

epsilon: f64

Positive numerical floor used in projection divisions and relative progress.

Implementations

impl AdaptiveAlternatingProjection

pub fn iterations(self, iterations: usize) -> Self

Sets the number of complete acquisition-schedule passes; validation requires non-zero.

pub fn initial_object_step(self, initial_object_step: f64) -> Self

Sets the finite positive initial object-projection relaxation.

pub fn progress_threshold(self, progress_threshold: f64) -> Self

Sets the required relative progress; validation requires [0, 1).

pub fn reduction_factor(self, reduction_factor: f64) -> Self

Sets the multiplicative reduction; validation requires (0, 1).

pub fn minimum_object_step(self, minimum_object_step: f64) -> Self

Sets the finite positive step floor, no greater than the initial step.

pub fn batch_size(self, batch_size: usize) -> Self

Sets the positive number of acquisition frames supplied per step.

pub fn epsilon(self, epsilon: f64) -> Self

Sets the finite positive numerical floor used by projection and feedback.

Trait Implementations

impl Clone for AdaptiveAlternatingProjection

fn clone(&self) -> AdaptiveAlternatingProjection

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for AdaptiveAlternatingProjection

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for AdaptiveAlternatingProjection

fn default() -> Self

Returns the “default value” for a type.

impl ReconstructionAlgorithm for AdaptiveAlternatingProjection

type IterationMetrics = AdaptiveAlternatingProjectionIterationMetrics

Algorithm-specific metrics emitted by each step and appended to the trace.

fn validate(&self) -> Result<()>

Validates solver parameters independently of a reconstruction problem.

fn initialize<M: MeasurementRead>( &self, problem: &ReconstructionProblem<M>, ) -> Result<ReconstructionState>

Creates the default CPU-backed state for problem.

fn initialize_with_backend<M: MeasurementRead>( &self, problem: &ReconstructionProblem<M>, backend: Arc<dyn Backend>, ) -> Result<ReconstructionState>

Creates reconstruction state using the supplied execution backend.

fn supports_joint_reconstruction(&self) -> bool

Reports whether the algorithm may run inside physical joint calibration.

fn step<M: MeasurementRead>( &mut self, problem: &ReconstructionProblem<M>, state: &mut ReconstructionState, batch: &Batch, iteration: usize, ) -> Result<StepOutput<Self::IterationMetrics>>

Updates state for one scheduled batch in zero-based iteration.

fn iterations(&self) -> usize

Returns the requested number of complete schedule passes.

fn batch_size(&self) -> usize

Returns the number of measured frames combined into one step.

fn validate_problem<M: MeasurementRead>( &self, _problem: &ReconstructionProblem<M>, ) -> Result<()>

Validates solver requirements that depend on problem.

fn canonicalize_state<M: MeasurementRead>( &self, _problem: &ReconstructionProblem<M>, _state: &mut ReconstructionState, ) -> Result<()>

Projects algorithm-owned ambiguities into a stable reported convention.

fn run<M: MeasurementRead>( self, problem: &ReconstructionProblem<M>, ) -> Result<ReconstructionResult>

where Self: Sized,

Runs the algorithm with default sequential scheduling and no callbacks.

fn run_with_callbacks<M: MeasurementRead>( self, problem: &ReconstructionProblem<M>, callbacks: Vec<Box<dyn Callback>>, ) -> Result<ReconstructionResult>

where Self: Sized,

Runs the algorithm and invokes callbacks at their declared hooks.

fn run_from_checkpoint<M: MeasurementRead>( self, problem: &ReconstructionProblem<M>, checkpoint: ReconstructionCheckpoint, ) -> Result<ReconstructionResult>

where Self: Sized,

Resumes a run from a checkpoint after validating it against problem.