#include <filesystem>

#include "model.hpp"

#include "constants.hpp"

#include "tile_bounds.hpp"

#include "project_gaussians.hpp"

#include "rasterize_gaussians.hpp"

#include "tensor_math.hpp"

#include "gsplat.hpp"

#include "utils.hpp"

#include <span>

#include "ply.hpp"

#ifdef USE_HIP

#include <c10/hip/HIPCachingAllocator.h>

#elif defined(USE_CUDA)

#include <c10/cuda/CUDACachingAllocator.h>

#endif

namespace fs = std::filesystem;

torch::Tensor randomQuatTensor(long long n){

}

torch::Tensor projectionMatrix(float zNear, float zFar, float fovX, float fovY, const torch::Device &device){

}

torch::Tensor psnr(const torch::Tensor& rendered, const torch::Tensor& gt){

torch::Tensor mse = (rendered - gt).pow(2).mean();

return (10.f * torch::log10(1.0 / mse));

}

torch::Tensor l1(const torch::Tensor& rendered, const torch::Tensor& gt){

return torch::abs(gt - rendered).mean();

}

Model::Model(const InputData &inputData,

}

Model::~Model()

{

releaseOptimizers();

}

void Model::setupOptimizers(){

}

void Model::releaseOptimizers()

}

ModelForwardResults Model::forward(Camera& cam,int step)

}

ModelForwardResults Model::forward(CameraTransform& CameraTransform,CameraIntrinsics renderIntrinsics,int step)

}

void Model::optimizersZeroGrad(){

}

void Model::optimizersStep(){

}

void Model::schedulersStep(int step){

meansOptScheduler->step(step);

}

int Model::getDownscaleFactor(int step)

}

void Model::addToOptimizer(torch::optim::Adam& optimizer, const torch::Tensor &newParam, const torch::Tensor &idcs, int nSamples){

}

void Model::removeFromOptimizer(torch::optim::Adam& optimizer, const torch::Tensor &newParam, const torch::Tensor &deletedMask){

}

void Model::afterTrain(int step,ModelForwardResults& ForwardMeta)

}

Model2DVisibility Model::calculateVisibility(ModelForwardResults& ForwardMeta)

}

void Model::flushAllocatorCaches()

}

void Model::doAlphaReset()

}

torch::Tensor Model::doSplits(int step,Model2DVisibility& Visibility,ModelForwardResults& ForwardMeta)

}

void Model::doCulls(int step,torch::Tensor& SplitsMask,Model2DVisibility& Visibility)

}

void Model::findInvalidPoints()

}

int Model::getPointCount()

}

void Model::iteratePoints(std::function<void(std::span<float> xyz,std::span<float> opacity,std::span<float> scale,std::span<float> quaternionwxyz,std::span<float> dcfeatures,std::span<float> restfeatures)> OnFoundPoint)

}

int Model::loadPly(const std::string &filename)

}

torch::Tensor Model::mainLoss(torch::Tensor &rgb, torch::Tensor &gt, float ssimWeight)

}