Welcome to Fractal Forums

   int count = 10;
  uint64 numBoxes[100];
  float dimension[100];
  for (int b = 0; b<100; b++)
  {
    count = count * 2;
    numBoxes[b] = 0;
    float boxDiameter = 2.f / (float)count;
    for (uint64 x = 0; x<count; x++)
    {
      float X = (0.5f+(float)x) * boxDiameter;
      for (uint64 y = 0; y<count; y++)
      {
        float Y = (0.5f+(float)y) * boxDiameter;
        for (uint64 z = x + y%2; z<count; z++) // starting at x means we only do half the work by exploiting symmetry
        {
          float Z = (0.5f+(float)z) * boxDiameter;
          Vector3 start(X,Y,Z);
          Vector3 point = start;
          float radius = 0.5f*boxDiameter;
          numBoxes[b]++; // in anticipation of it being inside
          for (int i = 0; radius<4.f; i++)
          {
            if (point.x > 1.f)
              point.x = 2.f - point.x;
            else if (point.x < -1.f)
              point.x = -2.f - point.x;
            if (point.y > 1.f)
              point.y = 2.f - point.y;
            else if (point.y < -1.f)
              point.y = -2.f - point.y;
            if (point.z > 1.f)
              point.z = 2.f - point.z;
            else if (point.z < -1.f)
              point.z = -2.f - point.z;
            float size = point.magnitudeSquared();
            if (size < 0.25f)
            {
              point *= 4.f;
              radius *= 4.f;
            }
            else if (size < 1)
            {
              point /= size;
              radius /= size;
            }
            point *= -2.f; // scale 2
            radius *= 2.f;
            point += start;
            float mag = max(abs(point.x), max(abs(point.y), abs(point.z)));
            if (mag > 6.f + radius)
            {
              numBoxes[b]--; // wasn't inside
              break; 
            }
          }
        }
      }
    }
    dimension[b] = logf(2.f*(float)numBoxes[b]) / logf((float)count);
    printf("dimension %f", dimension[b]);
  }

  int count = 10;
  uint64 numBoxes[100];
  float dimension[100];
  for (int b = 0; b<100; b++)
  {
    count = count * 2;
    numBoxes[b] = 0;
    float boxDiameter = 1.5f / (float)count;
    for (uint64 x = 0; x<count; x++)
    {
      float X = 1.5f + (0.5f+(float)x) * boxDiameter;
      for (uint64 y = 0; y<count; y++)
      {
        float Y = 1.5f + (0.5f+(float)y) * boxDiameter;
        for (uint64 z = x + y%2; z<count; z++) // starting at x means we only do half the work by exploiting symmetry
        {
          float Z = 1.5f + (0.5f+(float)z) * boxDiameter;
          Vector3 start(X,Y,Z);
          Vector3 point = start;
          float radius = 0.5f*boxDiameter;
          numBoxes[b]++; // in anticipation of it being inside
          for (int i = 0; ; i++)
          {
            if (point.x > 1+radius && point.x < 2-radius && point.y>1+radius && point.y < 2-radius)
            {
              numBoxes[b]--; 
              break; 
            }
            if (point.x > 1+radius && point.x < 2-radius && point.z>1+radius && point.z < 2-radius)
            {
              numBoxes[b]--; 
              break; 
            }
            if (point.z > 1+radius && point.z < 2-radius && point.y>1+radius && point.y < 2-radius)
            {
              numBoxes[b]--; 
              break; 
            }
            if (radius > 0.5f) // obviously the above can never be true in this case
            {
              break;
            }
            point *= 3.f;
            radius *= 3.f;
            point.x = fmodf(point.x, 3.f);
            point.y = fmodf(point.y, 3.f);
            point.z = fmodf(point.z, 3.f);
          }
        }
      }
    }
    dimension[b] = logf(2.f*(float)numBoxes[b]) / logf((float)count);
    printf("dimension %f", dimension[b]);
  }

  sx,sy,sz are starting x,y, and z components; nx, ny, and nz are calculated components before pixel component addition;
r1=sqrt(sqr(sy)+sqr(sz));
r3=r1^-n;   //take it to the negative power to avoid division by zero error!

victor=complex(sx,r1);   // complex (x,y) is ChaosPro's command to create a complex number out of 2 real components x and y
bravo=complex(sy,sz);  //  the second part (1st,2nd) is the imaginary component

victor=victor^n;
bravo=bravo^n;

nx=real (victor);
ny=imag (victor) * real (bravo) *r3;  //  you have to divide out the magnitude (r3=r1^n) because it has already been applied
nz=imag (victor) * imag (bravo) *r3;  //  twice, once computing victor, once computing bravo

  then add in your pixel values..