const data = [  {    text: '螺蛳粉',    fontSize: 40,    color: 'red'  },  {    text: '重庆小面',    fontSize: 35,    color: 'blue'  },  {    text: '肉夹馍',    fontSize: 35,    color: 'blue'  },  {    text: '炸酱面',    fontSize: 32,    color: 'blue'  },  {    text: '沙县小吃',    fontSize: 25,    color: 'blue'  },  {    text: '烤冷面',    fontSize: 23,    color: 'blue'  },  {    text: '臭豆腐',    fontSize: 23,    color: 'blue'  },  {    text: '钵钵鸡',    fontSize: 20,    color: 'red'  },  {    text: '酸辣粉',    fontSize: 19,    color: 'blue'  },  {    text: '冒菜',    fontSize: 15,    color: 'blue'  },  {    text: '驴打滚',    fontSize: 12,    color: 'blue'  },  {    text: '板栗',    fontSize: 11,    color: 'red'  },  {    text: '醪糟',    fontSize: 10,    color: 'blue'  }]

/** * 阿基米德螺线, 用于初始化位置函数, 调用后返回一个获取位置的函数 * @param {*} size 画布大小, [width, height] * @param {*} { step = 0.1, b = 1, a = 0 }  步长(弧度), 螺距, 起始点距中心的距离 * @returns  */export function archimedeanSpiral(size, { step = 0.1, b = 1, a = 0 } = {}) {  const e = size[0] / size[1]; // 根据画布长宽比例进行对应缩放  // 参数t为当前弧度值  return function(t) {    return [e * (a + b * (t *= step)) * Math.cos(t), (a + b * t) * Math.sin(t)];  };}/** * 辅助函数, 绘制阿基米德螺线 * @param {*} size 画布大小, [width, height] * @param {*} getPosition 布局函数, 调用archimedeanSpiral获取的返回值 * @param {*} params { showIndex } 是否显示序号  */export function paintSpiral (size, getPosition, { showIndex = false } = {}) {    const points = [] // 所有放置点    let dxdy,      maxDelta = Math.sqrt(size[0] * size[0] + size[1] * size[1]), // 最大半径      t = 1, // 阿基米德弧度      index = 0, // 当前位置序号      dx, // x坐标      dy; // y坐标    // 通过每次增加的步长固定为1，实际步长为 step * 1，来获取下一个放置点    while (dxdy = getPosition(t += 1)) {      dx = dxdy[0]      dy = dxdy[1]      if (Math.min(Math.abs(dx), Math.abs(dy)) >= maxDelta) break; // (dx, dy)距离中心超过maxDelta，跳出螺旋返回false      points.push([dx, dy, index++])    }    // 初始化画布    const canvas = document.createElement('canvas')    canvas.width = size[0]    canvas.height = size[1]    canvas.style.width = size[0]    canvas.style.height = size[1]    const ctx = canvas.getContext('2d')    ctx.fillStyle = '#f11';    ctx.strokeStyle = 'black';    let last = [0, 0]    // 将放置点绘制出来    for(let point of points) {      ctx.beginPath();      ctx.moveTo(last[0] + size[0] / 2, last[1] + size[1] / 2)      ctx.lineTo(point[0] + size[0] / 2, point[1] + size[1] / 2)      last = point      ctx.stroke();      ctx.beginPath();      ctx.arc(point[0] + size[0] / 2, point[1] + size[1] / 2, 2, 0, 2 * Math.PI, false);      ctx.font = '20px serif'      // 绘制序号      showIndex && ctx.fillText(point[2], point[0] + size[0] / 2, point[1] + size[1] / 2)      ctx.fill()    }    document.body.append(canvas)  }

// 画布宽高const CANVAS_SIZE = [500, 500]// 绘制螺线const getPosition = archimedeanSpiral(CANVAS_SIZE, { step: 0.1, b: 1 })paintSpiral(CANVAS_SIZE, getPosition, { showIndex: false })

const getPosition = archimedeanSpiral(CANVAS_SIZE, { step: 1, b: 10 })paintSpiral(CANVAS_SIZE, getPosition, { showIndex: true })

/** * 根据阿基米德螺线绘制词汇 * @param {*} data 词汇数据 * @param {*} getPosition 布局函数 */const drawWords = (data, size, getPosition, ) => {  let t = 0  const { context, canvas } = createCanvas(size[0], size[1])  data.forEach((word, index) => {    const [dx, dy] = getPosition(t += 1)    word.x = size[0] / 2 + dx    word.y = size[1] / 2 + dy    word.fontSize = Math.floor(word.fontSize / 2)    word.text = `${index}-${word.text}`    drawText(context, word)  })  document.body.appendChild(canvas)}

// 绘制一遍螺线用于对比const getPosition = archimedeanSpiral(CANVAS_SIZE, { step: 1, b: 10 })paintSpiral(CANVAS_SIZE, getPosition, { showIndex: true })// 绘制单词, 这里的data为文章开头的数据drawWords(data, size, getPosition)

/** * 打印像素占用数组 * @param {*} board  * @param {*} w  * @returns  */export const printPixelArray = (board, w) => {  let bitStr = ''  let intStr = ''  for (let i = 0; i < board.length / w; i++) {    for (let j = 0; j < w; j++) {      bitStr += `${(board[i * w + j] >>> 0).toString(2).padStart(32,'0')}|`      intStr += `${board[i * w + j].toString(10).padEnd(32)}|`    }    // 整数格式    bitStr += '\n'    // 二进制格式    intStr += '\n'  }  return { bitStr, intStr }}

/** * 根据数组中存储的像素信息绘制canvas * @param {*} board  * @param {*} paintSize  */export const paint = (board, paintSize) => {  const curSize = paintSize  const imageData = new ImageData(curSize[0], curSize[1]);  let array = imageData.data  for (let i = 0; i < curSize[1]; i++) {    for (let j = 0; j < (curSize[0] >> 5); j++) {      let value = board[i * (curSize[0] >> 5) + j]      for (let k = 0; k < 32; k++) {        // 遮罩，获取对应位置bit值        const msk = 0b1 << (32 - k)        if (value & msk) {          // 占用像素, 填充白色          for(let l = 0; l < 4; l++) {            array[i * curSize[0] * 4 + j * 32 * 4 + k * 4 + l] = 255;          }        } else {          // 未占用像素, 填充黑色          for(let l = 0; l < 3; l++) {            array[i * curSize[0] * 4 + j * 32 * 4 + k * 4 + l] = 0;          }          array[i * curSize[0] * 4 + j * 32 * 4 + k * 4 + 3] = 255;        }        // 数组元素分割线, 填充红色, 间隔32px        if (k === 0) {          array[i * curSize[0] * 4 + j * 32 * 4 + k * 4 + 0] = 255;          array[i * curSize[0] * 4 + j * 32 * 4 + k * 4 + 1] = 0;          array[i * curSize[0] * 4 + j * 32 * 4 + k * 4 + 2] = 0;        }      }    }  }  const canvas = document.createElement('canvas')  canvas.width = curSize[0]  canvas.height = curSize[1]  const ctx = canvas.getContext('2d')  ctx.putImageData(imageData, 0, 0)  canvas.style.marginRight = '10px'  document.body.appendChild(canvas)}

const word = data[0]// 绘制螺蛳粉的像素信息paint(word.sprite, [word.w, word.h])

const size = [500, 500] // [宽，高]const board = new Array(size[0], size[1]).fill(0)

/** * 获取单词sprite数组 * @param {*} contextAndRatio canvas上下文和画布比例 * @param {*} d 单词信息 * @param {*} data 所有单词 * @param {*} di 当前单词index */function cloudSprite(contextAndRatio, d, data, di) {  // 如果当前单词已经拥有sprite信息，跳过  if (d.sprite) return;  // 精灵图画布大小为2048 * 2048  var c = contextAndRatio.context,      ratio = contextAndRatio.ratio;  c.clearRect(0, 0, (cw << 5) / ratio, ch / ratio);  var x = 0,      y = 0,      maxh = 0,      n = data.length,      w, // 单词长度(px)      w32, // 画布长度(数组中一行的元素个数)      h, // 单词高(px)      i,      j;  --di;  while (++di < n) {    d = data[di];    c.save();    c.font = d.style + " " + d.weight + " " + ~~((d.size + 1) / ratio) + "px " + d.font; // 设置文字属性    w = c.measureText(d.text + "m").width * ratio; // 获取文字宽度    h = d.size << 1; // 因为没有获取文字高度的api，为了保证截取像素完整，默认高度为单词fontSize * 2    // 如果单词有旋转属性，计算旋转后的宽高    if (d.rotate) {      var sr = Math.sin(d.rotate * cloudRadians),          cr = Math.cos(d.rotate * cloudRadians),          wcr = w * cr,          wsr = w * sr,          hcr = h * cr,          hsr = h * sr;      w = (Math.max(Math.abs(wcr + hsr), Math.abs(wcr - hsr)) + 0x1f) >> 5 << 5;      h = ~~Math.max(Math.abs(wsr + hcr), Math.abs(wsr - hcr));    } else {      w = (w + 0x1f) >> 5 << 5;    }    // w, h为旋转后，词语所占区域的宽高    if (h > maxh) maxh = h; // 记录当前行最大高度    // 如果当前行放不下，就另起一行，y方向向下移动当前行的最大高度    if (x + w >= (cw << 5)) {      x = 0;      y += maxh;      maxh = 0;    }    if (y + h >= ch) break; // 绘制区域的高度为2048px，超过长度下次绘制    c.translate((x + (w >> 1)) / ratio, (y + (h >> 1)) / ratio);    if (d.rotate) c.rotate(d.rotate * cloudRadians);    c.fillText(d.text, 0, 0);    if (d.padding) {      c.lineWidth = 2 * d.padding;      c.strokeText(d.text, 0, 0);    }    c.restore();    // 词语绘制完成，记录其在画布上的相对位置和范围    d.width = w;    d.height = h;    d.xoff = x;    d.yoff = y;    // x0, x1, y0, y1是四角相对于中心点的相对坐标    d.x1 = w >> 1;    d.y1 = h >> 1;    d.x0 = -d.x1;    d.y0 = -d.y1;    d.hasText = true;    // x位置右移，等待下一个词语绘制    x += w;  }  // 获取整个精灵图画布的像素信息  var pixels = c.getImageData(0, 0, (cw << 5) / ratio, ch / ratio).data,      sprite = [];  // 根据单词的位置和长宽信息从pixels中截取并保存单词部分的像素信息  while (--di >= 0) {    d = data[di];    if (!d.hasText) continue;    w = d.width;    w32 = w >> 5;    h = d.y1 - d.y0;    // Zero the buffer    for (i = 0; i < h * w32; i++) sprite[i] = 0;    x = d.xoff;    if (x == null) return;    y = d.yoff;    var seen = 0,        seenRow = -1;    // 遍历像素，根据单词的绘制坐标与宽高信息，在画布中获取对应像素信息，保存至sprite    for (j = 0; j < h; j++) {      for (i = 0; i < w; i++) {        // 在sprite数组中，每一个Uint32的数字记录了32个像素的绘制情况        // 在pixels中，只取alpha通道的值，因此需要每个像素需要 << 2 得到alpha通道        var k = w32 * j + (i >> 5),            m = pixels[((y + j) * (cw << 5) + (x + i)) << 2] ? 1 << (31 - (i % 32)) : 0;        sprite[k] |= m; // 更新sprite对应像素信息        seen |= m; // 记录当前行是否有着色信息      }      // 如果当前行发现着色，开始记录行号      if (seen) seenRow = j;      else {        // 如果当前行未发现着色，则在结果中省去该行（高度--，y坐标++，左上角相对坐标++）        d.y0++;        h--;        j--;        y++;      }    }    d.y1 = d.y0 + seenRow; // 更新右下角相对坐标    d.sprite = sprite.slice(0, (d.y1 - d.y0) * w32); // 舍弃数组中冗余部分  }}// 获取单词的宽高、左右边界坐标、像素占用等信息。data.forEach((word, index) => cloudSprite(contextAndRatio, word, data, index))

const word = {    w: number; // 宽    h: number; // 高    x0: number; // x左边界偏移量，<= 0    x1: number; // x右边界偏移量，>= 0    y0: number; // y上边界偏移量，<= 0    y1: number; // y下边界偏移量，>= 0    sprite: number[]; // 单词的像素占用信息，数组长度为w * h / 32    x: number; // 绘制坐标    y: number; // 绘制坐标}

A = 0b1001B = 0b0011

// 设wordSpriteLeft为第一行第一个数值// wordSpriteRight为第一行第二个数值// 设偏移量为x// 获取第一个数值右侧部分const leftPartInBoard = wordSpriteLeft << (32 - x)// 获取第二个数值左侧部分const rightPartInBoard = wordSpriteRight >> x// 合并组成新数值const newValue = leftPartInBoard | rightPartInBoard// 碰撞检测const isCollide = newValue & board[i]

/** * 检测单词是否重叠 * @param {*} tag 单词 * @param {*} board 画布像素占用信息 * @param {*} sw 画布长度 */function cloudCollide(tag, board, sw) {  sw >>= 5; // 获取画布长度在数组中对应的宽度  var sprite = tag.sprite,      w = tag.width >> 5, // 单词在数组中的宽      lx = tag.x - (w << 4), // 单词左边界x坐标(px)      sx = lx & 0x7f, // 单词偏移（px）, 当前元素右侧移除数量      msx = 32 - sx, // 需要从sprite上一个元素中移除的数量      h = tag.y1 - tag.y0, // 单词高度      x = (tag.y + tag.y0) * sw + (lx >> 5), // 数组中的起始位置      last;  // 逐行遍历单词sprite，判断与已绘制内容重叠  for (var j = 0; j < h; j++) {    last = 0;    for (var i = 0; i <= w; i++) {      // last << msx 获取sprite前一个元素超出board左侧边界的部分      // (last = sprite[j * w + i]) >>> sx 获取sprite超出board右侧边界的部分，并将值赋给last，便于下一个元素的计算      // 将以上两部分进行"或"操作，合并成完整的32位像素信息      // 将新合并的数字与board对应数组进行"与"操作，值为0则不重叠，返回true，否则返回false      if (((last << msx) | (i < w ? (last = sprite[j * w + i]) >>> sx : 0))          & board[x + i]) return true;    }    x += sw;  }  return false;}

// 遍历螺线线上的点，检测单词是否可以放置export const place = (board, word, bounds, size, getPosition) => {  const startX = word.x; // 初始值为画布 x 中点  const startY = word.y; // 初始值为画布 y 中点  const maxDelta = Math.sqrt(size[0] * size[0] + size[1] * size[1])  const s = getPosition; // 阿基米德螺线函数  const dt = Math.random() < .5 ? 1 : -1;  let t = -dt;  let dxdy,      dx,      dy;  while (dxdy = s(t += dt)) {    dx = ~~dxdy[0]; // x 偏移量    dy = ~~dxdy[1]; // y 偏移量    // 超出最大范围，单词无法放置    if (Math.min(Math.abs(dx), Math.abs(dy)) >= maxDelta) break;    word.x = startX + dx; // 获取单词在画布中的 x 坐标    word.y = startY + dy; // 获取单词在画布中的 y 坐标    // 文字超出画布范围时跳过    if (word.x + word.x0 < 0 || word.y + word.y0 < 0 ||        word.x + word.x1 > size[0] || word.y + word.y1 > size[1]) continue;    // 碰撞检测    if (!bounds || !cloudCollide(word, board, size[0])) {      // 与board进行像素对比      if (!bounds || collideRects(word, bounds)) {        // 将单词的像素占用信息更新到board        let sprite = word.sprite,            w = word.width >> 5,            sw = size[0] >> 5,            lx = word.x - (w << 4),            sx = lx & 0x7f, // sprite数组左侧偏移            msx = 32 - sx, // 位移遮罩            h = word.y1 - word.y0,            x = (word.y + word.y0) * sw + (lx >> 5),            last;        // 逐行遍历        for (let j = 0; j < h; j++) {          last = 0;          for (let i = 0; i <= w; i++) {            board[x + i] |= (last << msx) | (i < w ? (last = sprite[j * w + i]) >>> sx : 0);          }          x += sw;        }        word.sprite = null;        // 可以放置该单词        return true;      }    }  }  // 该单词无法放置  return false;}

/** * 渲染词云 * @param {*} size  * @param {*} data  */const renderWordCloud = (size, data) => {  const center = [size[0] / 2, size[1] / 2]  const results = []  const board = new Array((size[0] >> 5) * size[1]).fill(0);  const getPosition = archimedeanSpiral(size);  // const getPosition = archimedeanSpiral(size, {step: 1, b: 10});  let bounds = null  let i = 0  // data = data.map((data, i) => {data.text = `${i}${data.text}`;return data})  while (i < data.length) {    var d = data[i];    d.x = center[0]    d.y = center[1]    // 收集词汇像素占用情况    cloudSprite(cloudSpriteCanvasInfo, d, data, i, size[0] >> 5, size[1]);    if (d.hasText && place(board, d, bounds, [...size], getPosition)) {      results.push(d);      if (bounds) cloudBounds(bounds, d);      else bounds = [{x: d.x + d.x0, y: d.y + d.y0}, {x: d.x + d.x1, y: d.y + d.y1}];      // Temporary hack      d.x -= size[0] >> 1;      d.y -= size[1] >> 1;    }    i++  }  const resultCanvasInfo = createCanvas(size[0], size[1])  results.map(word => {    word.x = word.x + center[0];    word.y = word.y + center[1];    return word  }).forEach(word => drawText(resultCanvasInfo.context, word))  paint(board, size)  document.body.appendChild(resultCanvasInfo.canvas)}