std::vector<std::string> petabricks::IterationDefinition::packedargs() const {
  std::string t[] = {
    "IndexT "COORD_BEGIN_STR"["+jalib::XToString(dimensions())+"]",
    "IndexT "COORD_END_STR"["+jalib::XToString(dimensions())+"]"
  };
  return std::vector<std::string>(t, t+2);
}

/**
 * See also constructor that takes a std::istream.
 */
bool HaarWavelet::write(std::ostream &output) const
{
    if (dimensions() == 0) //won't store a meaningless wavelet
    {
        return false;
    }

    output << dimensions() << ' ';

    bool first = true;
    for (unsigned int i = 0; i < dimensions(); i++)
    {
        if (first)
        {
            first = false;
        }
        else
        {
            output << ' ';
        }
        output << rects[i].x << ' '
               << rects[i].y << ' '
               << rects[i].width << ' '
               << rects[i].height << ' '
               << weights[i];
    }

    return true;
}

Expr ImageParam::operator()() const {
    user_assert(dimensions() == 0)
        << "Zero-argument access to Buffer " << name()
        << ", which has " << dimensions() << "dimensions.\n";
    std::vector<Expr> args;
    return Internal::Call::make(param, args);
}

int QPushButton::baselinePosition(int height) const
{
    // Button text is centered vertically, with a fudge factor to account for the shadow.

    return (int)ceil(-dimensions()[topMargin]
        + ((height + dimensions()[topMargin] + dimensions()[bottomMargin])) / 2.0
        - dimensions()[baselineFudgeFactor]);
}

 int DynImage::size(int i) const {
     if (i >= dimensions()) {
         fprintf(stderr,
                 "ERROR: accessing size of dim %d of %d-dimensional image %s\n",
                 i, dimensions(), name().c_str());
         assert(i < dimensions());
     }
     return contents->size[i];
 }

void Grid::__init() {
	gSize = indexSize();

	if (trueDimensions() != dimensions())
		cout << gridName << ": dim = " << dimensions() << ", trueDim = "
				<< trueDimensions() << ", index range = " << String(getN())
				<< ", index size = " << indexSize() << endl;

}

bool MyHaarWavelet::read(std::istream &input)
{
    if ( !HaarWavelet::read(input) )
    {
        return false;
    }

    means.resize(dimensions());
    for (unsigned int i = 0; i < dimensions(); i++)
    {
        input >> means[i];
    }

    return true;
}

SequenceDataPtr TransposeTransformer::TypedApply(SequenceDataPtr sequence,
                                                 const StreamDescription &inputStream,
                                                 const StreamDescription &outputStream)
{
    assert(inputStream.m_storageType == StorageType::dense);
    auto inputSequence = static_cast<DenseSequenceData&>(*sequence.get());
    assert(inputSequence.m_numberOfSamples == 1);
    assert(inputStream.m_sampleLayout->GetNumElements() == outputStream.m_sampleLayout->GetNumElements());

    size_t count = inputStream.m_sampleLayout->GetNumElements() * GetSizeByType(inputStream.m_elementType);

    auto result = std::make_shared<DenseSequenceWithBuffer>();
    result->m_buffer.resize(count);

    ImageDimensions dimensions(*inputStream.m_sampleLayout, ImageLayoutKind::HWC);
    size_t rowCount = dimensions.m_height * dimensions.m_width;
    size_t channelCount = dimensions.m_numChannels;

    auto src = reinterpret_cast<TElemType*>(inputSequence.m_data);
    auto dst = reinterpret_cast<TElemType*>(result->m_buffer.data());

    for (size_t irow = 0; irow < rowCount; irow++)
    {
        for (size_t icol = 0; icol < channelCount; icol++)
        {
            dst[icol * rowCount + irow] = src[irow * channelCount + icol];
        }
    }

    result->m_sampleLayout = outputStream.m_sampleLayout;
    result->m_data = result->m_buffer.data();
    result->m_numberOfSamples = inputSequence.m_numberOfSamples;
    return result;
}

void TransposeTransformer::Initialize(TransformerPtr next,
                                      const ConfigParameters &readerConfig)
{
    TransformerBase::Initialize(next, readerConfig);

    // Currently we only support a single stream.
    ImageConfigHelper config(readerConfig);
    size_t featureStreamId = config.GetFeatureStreamId();
    m_appliedStreamIds.push_back(featureStreamId);

    const auto &inputStreams = GetInputStreams();
    m_outputStreams.resize(inputStreams.size());
    std::copy(inputStreams.begin(), inputStreams.end(), m_outputStreams.begin());

    for (auto id : m_appliedStreamIds)
    {
        auto &stream = inputStreams[id];

        ImageDimensions dimensions(*stream->m_sampleLayout, HWC);

        // Changing from NHWC to NCHW
        auto changedStream = std::make_shared<StreamDescription>(*stream);
        changedStream->m_sampleLayout = std::make_shared<TensorShape>(dimensions.AsTensorShape(CHW));
        m_outputStreams[id] = changedStream;
    }
}

void Player::init(b2World* world, const glm::vec2& position, taengine::SoundEffect jumpEffect) {
	m_hitbox = new Box;
	glm::vec2 dimensions(1.0f, 2.5f);
	static_cast<Box*> (m_hitbox)->init(world, b2_dynamicBody, position, true, false,
		dimensions, 1.0f, 1.0f, 0.0f, false, FixtureTag::PLAYER_BODY, FixtureTag::ALL);

	m_hitbox->getBody()->SetLinearDamping(2.0f);
	m_hitbox->getBody()->SetUserData(this);

	//add foot sensor fixture
	b2PolygonShape polygonShape;
	polygonShape.SetAsBox(0.45f, 0.2f, b2Vec2(0, -1.25f), 0);
	b2FixtureDef fixtureDef;
	fixtureDef.isSensor = true;
	fixtureDef.shape = &polygonShape;
	fixtureDef.filter.categoryBits = FixtureTag::PLAYER_FOOT;
	fixtureDef.filter.maskBits = FixtureTag::WALL | FixtureTag::ENEMY_BODY;
	b2Fixture* footSensorFixture = m_hitbox->getBody()->CreateFixture(&fixtureDef);
	footSensorFixture->SetUserData((void*)3);

	m_tileSheet.init(taengine::ResourceManager::getTexture("Sprites/anya.png"), glm::ivec2(7, 4));
	m_drawDimensions = glm::vec2(3.0f, 3.0f);

	m_jumpEffect = jumpEffect;

	m_animationSpeed = 0.15f;
	m_animationTime = 0.0f;

	m_direction = 1;

	m_footContacts = 0;

	m_killCount = 0;
	m_moveState = PlayerMoveState::STANDING;
}

void paper_set_units(paper_s *p, units_t ut)
{
    // Sanity check parameters.
  assert(p);
  p->units = ut;
  dimensions(p);
}

void
TexelStoreGL::
resize_implement(int new_num_layers)
{
  fastuidraw::ivec3 dims(dimensions());
  int old_num_layers(dims.z());

  if(m_texture_as_r8 != 0)
    {
      /* a resize generates a new texture which then has
         a new backing store. The texture view would then
         be using the old backing store which is useless.
         We delete the old texture view and let texture()
         recreate the view on demand.
       */
      glDeleteTextures(1, &m_texture_as_r8);
      m_texture_as_r8 = 0;
    }

  dims.z() = new_num_layers;
  m_backing_store.resize(dims);

  std::vector<uint8_t> right(dims.y(), 0), bottom(dims.x(), 0);
  for(int layer = old_num_layers; layer < new_num_layers; ++layer)
    {
      set_data(dims.x() - 1, 0, layer, //top right
               1, dims.y(), //entire height
               fastuidraw::make_c_array(right));

      set_data(0, dims.y() - 1, layer, //bottom left
               dims.x() - 1, 1, //entire width
               fastuidraw::make_c_array(bottom));
    }
}

void
BackingStore::
resize_implement(int new_num_layers)
{
  fastuidraw::ivec2 dims(dimensions());
  m_backing_store.resize(dimensions_for_store(dims.x(), new_num_layers));
}

ImageDataDeserializer::ImageDataDeserializer(const ConfigParameters& config)
{
    ImageConfigHelper configHelper(config);
    m_streams = configHelper.GetStreams();
    assert(m_streams.size() == 2);
    const auto& label = m_streams[configHelper.GetLabelStreamId()];
    const auto& feature = m_streams[configHelper.GetFeatureStreamId()];

    // Expect data in HWC.
    ImageDimensions dimensions(*feature->m_sampleLayout, configHelper.GetDataFormat());
    feature->m_sampleLayout = std::make_shared<TensorShape>(dimensions.AsTensorShape(HWC));

    label->m_storageType = StorageType::sparse_csc;
    feature->m_storageType = StorageType::dense;

    m_featureElementType = feature->m_elementType;
    size_t labelDimension = label->m_sampleLayout->GetDim(0);

    if (label->m_elementType == ElementType::tfloat)
    {
        m_labelGenerator = std::make_shared<TypedLabelGenerator<float>>();
    }
    else if (label->m_elementType == ElementType::tdouble)
    {
        m_labelGenerator = std::make_shared<TypedLabelGenerator<double>>();
    }
    else
    {
        RuntimeError("Unsupported label element type '%d'.", label->m_elementType);
    }

    CreateSequenceDescriptions(configHelper.GetMapPath(), labelDimension);
}

SummaryConfig::SummaryConfig( const Deck& deck, const EclipseState& es , const ParseContext& parseContext)
    : SummaryConfig( deck,
                        *es.getSchedule(),
                        es.get3DProperties(),
                        parseContext,
                        dimensions( *es.getInputGrid() ) )
{}

 /// Evaluate gradients of all basis functions associated with
 /// cell at x, writing to grad_f_x. The array grad_f_x must
 /// have size numBasisFunc() * dimensions().  The dimensions()
 /// components of the first basis function gradient come
 /// before the components of the second etc.
 void DGBasisMultilin::evalGrad(const int cell,
                                const double* x,
                                double* grad_f_x) const
 {
     const int dim = dimensions();
     const int num_basis = numBasisFunc();
         const double* cc = grid_.cell_centroids + dim*cell;
         switch (degree_) {
         case 0:
             std::fill(grad_f_x, grad_f_x + num_basis*dim, 0.0);
             break;
         case 1:
             std::fill(grad_f_x, grad_f_x + num_basis*dim, 1.0);
             for (int dd = 0; dd < dim; ++dd) {
                 const double f[2] = { 0.5 - x[dd] + cc[dd],  0.5 + x[dd] - cc[dd] };
                 const double fder[2] = { -1.0,  1.0 };
                 const int divi = 1 << (dim - dd - 1); // { 4, 2, 1 } for 3d, for example.
                 for (int ix = 0; ix < num_basis; ++ix) {
                     const int ind = (ix/divi) % 2;
                     for (int dder = 0; dder < dim; ++dder) {
                         grad_f_x[ix*dim + dder] *= (dder == dd ? fder[ind] : f[ind]);
                     }
                 }
             }
             break;
         default:
             OPM_THROW(std::runtime_error, "Maximum degree is 1 for now.");
         }
 }

void Bloom::captureBackBuffer()
{
	DX::Viewport vp;

	vp.X = vp.Y = 0;
	vp.MinZ = 0;
	vp.MaxZ = 1;
	vp.Width = bbWidth_;
	vp.Height = bbHeight_;

	if ( wasteOfMemory_->valid() && wasteOfMemory_->push() )
	{
		Moo::rc().setViewport( &vp );
		colourScaleParameters_.setTexture( "diffuseMap", FullScreenBackBuffer::renderTarget().pTexture() );	

		if (colourScale_->begin())
		{
			for ( uint32 i=0; i<colourScale_->nPasses(); i++ )
			{
				colourScale_->beginPass(i);
				// note bbc_ always applies pixel-texel alignment correction
				Vector2 tl(0,0);
				Vector2 dimensions((float)bbWidth_,(float)bbHeight_);
				bbc_->draw( tl, dimensions, tl, dimensions, true);
				colourScale_->endPass();
			}
			colourScale_->end();
		}
		
			
		wasteOfMemory_->pop();
	}
}

void VolumeResample::resampleVolume() {
    tgtAssert(inport_.hasData(), "Inport has not data");
    forceUpdate_ = false;

    if (inport_.getData()->getRepresentation<Volume>()) {

        Volume::Filter filter;
        if (filteringMode_.isSelected("nearest"))
            filter = Volume::NEAREST;
        else if (filteringMode_.isSelected("linear"))
            filter = Volume::LINEAR;
        else if (filteringMode_.isSelected("cubic"))
            filter = Volume::CUBIC;
        else {
            LERROR("Unknown filter mode: " << filteringMode_.get());
            return;
        }        

        tgt::ivec3 dimensions(resampleDimensionX_.get(), resampleDimensionY_.get(), resampleDimensionZ_.get());
        try {
            VolumeHandle* v = VolumeOperatorResample::APPLY_OP(inport_.getData(), dimensions, filter, progressBar_);
            outport_.setData(v);
        }
        catch (const std::bad_alloc&) {
            LERROR("resampleVolume(): bad allocation");
            outport_.setData(0);
        }
    }
    else {
        outport_.setData(0);
    }
}

void paper_set_orientation(paper_s *p, paper_orientation_t o)
{
    // Sanity check parameters.
  assert(p);
  p->orientation = o;
  dimensions(p);
}

			void PixelBufferGL15::blitFrom(AE::Graphics::ColorBuffer *source, AE::Math::Point2<AE::uint> srcOffset, AE::Math::Point2<AE::uint> srcDimensions, AE::Math::Point2<AE::int32> const &destPosition)
			{
				assert(srcDimensions.x >= srcOffset.x && 
					   srcDimensions.y >= srcOffset.y);

				void *pixels = source->getData();

				glBindTexture(GL_TEXTURE_2D, mTextureGL);

				AE::int32 y;
				AE::Math::Point2<AE::uint> dimensions(srcDimensions.x - srcOffset.x, srcDimensions.y - srcOffset.y);

				if(AE::Graphics::AxesConvention2d::verticalDirection == AE::Graphics::VD_BOTTOM_TO_TOP)
					y = mDimensions.y - destPosition.y - dimensions.y;
				else
					y = destPosition.y;

				glTexSubImage2D(GL_TEXTURE_2D, 0, 
								destPosition.x, y, 
								dimensions.x, dimensions.y, 
								static_cast<AE::Graphics::Device::PixelBufferGL15 *>(source)->mPixelFormatGL, 
								static_cast<AE::Graphics::Device::PixelBufferGL15 *>(source)->mTypeGL, 
								pixels);

				GLenum error = glGetError();
				assert(error == 0);
			}