Gostaria de comparar duas imagens e encontrar a posição do modelo dentro da segunda imagem, então a primeira imagem é esta:

Esta é a nossa imagem de modelo que deve ser comparada com a imagem a seguir:

Mas quando executo o código, obtive o seguinte resultado:

Como posso melhorar o resultado?

import cv2
import numpy as np
from imutils.object_detection import non_max_suppression
import matplotlib.pyplot as plt
template =cv2.imread("euro.jpg",cv2.IMREAD_COLOR)
template =cv2.resize(template,(99,99))
img =cv2.imread("euro_2024.jpg",cv2.IMREAD_COLOR)
img2 = img.copy()
# image =cv2.resize(image,(700,700))
h,w =template.shape[:2]

# All the 6 methods for comparison in a list
methods = ['cv2.TM_CCOEFF', 'cv2.TM_CCOEFF_NORMED', 'cv2.TM_CCORR',
            'cv2.TM_CCORR_NORMED', 'cv2.TM_SQDIFF', 'cv2.TM_SQDIFF_NORMED']

for meth in methods:
    img = img2.copy()
    method = eval(meth)

    # Apply template Matching
    res = cv2.matchTemplate(img,template,method)
    min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(res)

    # If the method is TM_SQDIFF or TM_SQDIFF_NORMED, take minimum
    if method in [cv2.TM_SQDIFF, cv2.TM_SQDIFF_NORMED]:
        top_left = min_loc
    else:
        top_left = max_loc
    bottom_right = (top_left[0] + w, top_left[1] + h)

    cv2.rectangle(img,top_left, bottom_right, 255, 2)

    plt.subplot(121),plt.imshow(res,cmap = 'gray')
    plt.title('Matching Result'), plt.xticks([]), plt.yticks([])
    plt.subplot(122),plt.imshow(img,cmap = 'gray')
    plt.title('Detected Point'), plt.xticks([]), plt.yticks([])
    plt.suptitle(meth)

    plt.show()

Por que o código a seguir é produzido -1quando compilado usando g++ -O1? Minha versão do gcc é 13.2.1.

#include <iostream>
#include <cmath>
#include <cfenv>

using namespace std;

int main() {
    fesetround(FE_DOWNWARD);
    cout << rint(-1.6) << endl;
    return 0;
}

Polars noob, dado um m x ndataframe Polars dfe um 1 x ndataframe Polars de escalares, quero dividir cada coluna dfpelo escalar correspondente no outro quadro.

import numpy as np
import polars as pl

cols = list('abc')
df = pl.DataFrame(np.linspace(1, 9, 9).reshape(3, 3),
                  schema=cols)
scalars = pl.DataFrame(np.linspace(1, 3, 3)[:, None],
                       schema=cols)

In [13]: df
Out[13]: 
shape: (3, 3)
┌─────┬─────┬─────┐
│ a   ┆ b   ┆ c   │
│ --- ┆ --- ┆ --- │
│ f64 ┆ f64 ┆ f64 │
╞═════╪═════╪═════╡
│ 1.0 ┆ 2.0 ┆ 3.0 │
│ 4.0 ┆ 5.0 ┆ 6.0 │
│ 7.0 ┆ 8.0 ┆ 9.0 │
└─────┴─────┴─────┘

In [14]: scalars
Out[14]: 
shape: (1, 3)
┌─────┬─────┬─────┐
│ a   ┆ b   ┆ c   │
│ --- ┆ --- ┆ --- │
│ f64 ┆ f64 ┆ f64 │
╞═════╪═════╪═════╡
│ 1.0 ┆ 2.0 ┆ 3.0 │
└─────┴─────┴─────┘

Posso fazer isso facilmente no Pandas, conforme mostrado abaixo, delegando à transmissão NumPy, mas queria saber qual a melhor maneira de fazer isso sem ir e voltar entre as representações Polars/Pandas.

In [16]: df.to_pandas() / scalars.to_numpy()
Out[16]: 
     a    b    c
0  1.0  1.0  1.0
1  4.0  2.5  2.0
2  7.0  4.0  3.0

Encontrei esta pergunta semelhante em que a constante escalar já é uma linha no quadro original, mas não vejo como aproveitar uma linha de outro quadro.

O melhor que consegui até agora foi combinar as molduras e fazer algumas... coisas horríveis :D

In [31]: (pl.concat([df, scalars])
    ...:    .with_columns(pl.all() / pl.all().tail(1))
    ...:    .head(-1))
Out[31]: 
shape: (3, 3)
┌─────┬─────┬─────┐
│ a   ┆ b   ┆ c   │
│ --- ┆ --- ┆ --- │
│ f64 ┆ f64 ┆ f64 │
╞═════╪═════╪═════╡
│ 1.0 ┆ 1.0 ┆ 1.0 │
│ 4.0 ┆ 2.5 ┆ 2.0 │
│ 7.0 ┆ 4.0 ┆ 3.0 │
└─────┴─────┴─────┘

Tentei as duas maneiras a seguir para definir minHeight e minWidth para um AnchorPane em JavaFX (de forma que não seja redimensionável em 1280x720):

Da classe do controlador (que é chamada de um Button em um login-view.fxml que possui os mesmos valores mínimo e máximo para altura e largura, mas apenas localmente e nada é transferido para admin-view.fxml).

root, stage, scene são declarados no LoginController, mas não são

root = FXMLLoader.load(getClass().getResource("admin-view.fxml"));
stage = (Stage) ((Node) event.getSource()).getScene().getWindow();


scene = new Scene(root);
stage.setScene(scene);
stage.setMinHeight(scene.getRoot().minHeight(-1));
stage.setMinWidth(scene.getRoot().minWidth(-1));

e

stage.setMinHeight(720);
stage.setMinWidth(1280);

e em admin-view.fxml

<VBox maxHeight="720.0" maxWidth="1280.0" minHeight="720.0" minWidth="1280.0" ...>
    <children>
    <VBox VBox.vgrow="ALWAYS" />
        <AnchorPane maxHeight="720.0" maxWidth="1280.0" minHeight="720.0" minWidth="1280.0">
    ... my code here ...
    <VBox VBox.vgrow="ALWAYS" />
    </children>
<VBox>

(Selecionei os valores mínimo e máximo iguais porque vi em um tutorial que isso deve funcionar).

Mas meu problema é que o tamanho da janela está carregando em 1280x720, mas é redimensionável para ~1260x690.

Eu tenho um mapa Map<MetricResult, Long> metricResultToComputationTime.

MetricResulttem um método MetricResult::getEndTime.

Quero chegar a um List<MetricResult>local onde cada um MetricResulttenha um horário de término único. Se os horários finais corresponderem, quero usar aquele com maior tempo de computação do mapa. Como faço isso de maneira organizada?

Eu sei que existem maneiras simples e prolixas de fazer isso, mas estou procurando algo elegante.

Eu tentei algumas coisas assim:

List<MetricResult> metricResults =
    metricResultToComputationTime.entrySet().stream()
        .collect(
            groupingBy(
                MetricResult::getEndTime,
                collectingAndThen(maxBy(Map.Entry.comparingByValue()), Optional::get)))
        .values();

Mas não compila

Erro:

nenhum método adequado encontrado para collect(java.util.stream.Collector<MetricResult&java.util.Map.Entry<java.lang.Object,V>,capture#1 of ?,java.util.Map<Timestamp,java.lang. Objeto >>) método java.util.stream.Stream.collect(java.util.function.Supplier,java.util.function.BiConsumer<R,? super java.util.Map.Entry<MetricResult,Timestamp>>,java .util.function.BiConsumer<R,R>) não é aplicável (a variável de inferência T tem limites superiores incompatíveis: MetricResult,java.util.Map.Entry<K,V>,T,T limites inferiores: MetricResult,Timestamp> )

Considere a definição de compare_and_exchange_strong_explicit:

_Bool atomic_compare_exchange_strong_explicit( volatile A* obj,
                                               C* expected, C desired,
                                               memory_order succ,
                                               memory_order fail );

Estou confuso com o caso de uso do memory_order fail. Considerando o x86, está perfeitamente claro que lock cmpxchgpode falhar, mas também está claramente definido que (enfatize o meu)

Leituras ou gravações não podem ser reordenadas com instruções de E/S, instruções bloqueadas ou instruções de serialização

o que torna o memory_order failtipo irrelevante, pois lockgarante consistência sequencial em qualquer caso.

Exemplo :

#include <stdatomic.h>

void fail_seqcst(volatile int *p, int *expected, int *desirable){
    atomic_compare_exchange_strong_explicit(p, expected, desirable, memory_order_release, memory_order_seq_cst);
}

void fail_relaxed(volatile int *p, int *expected, int *desirable){
    atomic_compare_exchange_strong_explicit(p, expected, desirable, memory_order_release, memory_order_relaxed);
}

Compila para :

fail_relaxed:
        mov       ecx, edx                                      
        mov       eax, DWORD PTR [rsi]                          
        lock      
        cmpxchg   DWORD PTR [rdi], ecx                          
        mov       DWORD PTR [rsi], eax                          
        sete      al                                            
        movzx     eax, al                                       
        ret 

fail_seqcst:
        mov       ecx, edx                                      
        mov       eax, DWORD PTR [rsi]                          
        lock      
        cmpxchg   DWORD PTR [rdi], ecx                          
        mov       DWORD PTR [rsi], eax                          
        sete      al                                            
        movzx     eax, al                                       
        ret                                                     

Raio Deus

Existe alguma otimização que o compilador possa fazer que diferencie o código memory_order_relaxede, memory_order_seq_cstnesse caso, em x86? Ou talvez exista uma arquitetura que possa tornar essa diferença significativa?

Eu tenho duas colunas: serial_numbere inv_numbercontendo listas. Se houver um inv_numberpara multiple serial_number, preciso fazer com que o tamanho da inv_numberlista seja igual ao serial_numberde.

    serial_number                                       inv_number
28  [С029768, С029775]                                  [101040031171, 101040031172]
29  [090020960190402011, 090020960190402009]            [210134002523, 210134002524]
31  [1094]                                              [410124000215]
32  [01]                                                [101040022094]
33  [F161B5, F17D86, F17D8D, F1825C, F1825A, F1825D]    [101040026976]

Aqui no índice 33 temos 6 números de série mas um número de inventário, então deve ser alterado para

[101040026976, 101040026976, 101040026976, 101040026976, 101040026976, 101040026976]

Eu tentei fazer isso "multiplicando" valores para fazer uma lista (como [value] * N):

si.loc[si['inv_number'].apply(len)==1, 'inv_number'].apply
    (lambda x: [str(x[0])] * si['serial_number'].apply(len).values)

mas me dá um erro:

UFuncTypeError: ufunc 'multiply' não continha um loop com tipos correspondentes de assinatura (dtype('<U12'), dtype('int64')) -> None

Como posso resolver esse problema?

Sinto muito, sou meio novo em codificação, mas me pediram para pegar um número inteiro como entrada para o enésimo termo e imprimir o valor desse padrão, e escrevi algo que funciona da maneira que sinto, como se eu estou muito complicando as coisas. Aqui está a série em questão:

y = -(1)-(1+2)+(1+2+3)+(1+2+3+4)-(1+2+3+4+5) .... (1+2 +3+4...+n)

Aqui está o código:

import java.util.Scanner;
public class wontwork {
  public static void main(String[] args) {
   Scanner np = new Scanner(System.in);
   
    System.out.println("Enter n");
    int n = np.nextInt();
    int count = 1;
    int sum = 0;
    int y = 0;
    
    for(int i = 1; i<=n ; i+=2) {
      
      if(count%2==0) {
        sum+=i;
        y+=sum;
        sum+=i+1;
        y+=sum;
      }
      else {
        sum+=i;
        y-=sum; 
        sum+=i+1;
        y-=sum;
      }
      count++;
    }
    
    if(n%2!=0) {
      
      if (count%2==0) {
        System.out.print(y+sum);
      }
      else {
        System.out.print(y-sum);
      }

  }
    else {
      System.out.print(y);
  }
  np.close();
}
}

Uma saída de amostra deve fornecer 12 quando a entrada 4 e -3 quando a entrada 5.

Pelo que entendi é subtrair duas vezes e somar duas vezes a soma dos valores. E o que eu fiz foi criar um loop for e pegar uma variável de contagem que verifica se deve primeiro adicionar ou subtrair dependendo se é ímpar ou par e então pegar uma variável de soma para calcular os valores de cada iteração entre colchetes e adicionar ou subtraímos isso para y.

Mas para cada vez que o loop é executado, esse processo acontece duas vezes. Então y é adicionado por -(1) e -(1+2) o primeiro loop quando a contagem é ímpar e depois por (1+2+3) e (1+2+3+4) no próximo quando a contagem é par. Eu fiz isso porque se eu somar digamos (1+2+3) individualmente sendo a contagem par, tenho que somar também (1+2+3+4) e incrementar a contagem, porém, isso a torna ímpar, e é não é mais útil usar isso para adicionar ou subtrair. Eu odiaria se estivesse faltando algo óbvio, mas não consigo descobrir de que outra forma saber quando é incrementado duas vezes para torná-lo positivo ou negativo.

Por esse motivo, também, se não fosse pela instrução if else no final, o programa apenas gera os valores corretos para cada 2n e para corrigir isso peguei o último valor da soma armazenado e verifiquei se a contagem é ímpar ou par e então adicionei ou subtraído novamente com y para encontrar o valor médio de n. Peço desculpas se não escrevi ou formatei nada incorretamente, pois este é meu primeiro post aqui, mas deixe-me saber o que mais posso fazer. Eu apreciaria qualquer ajuda.

O método renderHanoi() deve mover os discos, limpando-os dos VBoxes e adicionando-os novamente na nova ordem após cada movimento ser feito, mas parece que nada é mostrado a menos que seja o último movimento, o que torna tudo bastante inútil .

Tentei diferentes métodos de criação de atrasos, como Thread.sleep, Platform.runLater, etc. Nenhum deles parece funcionar. Como faço para resolver isso?

import java.util.Arrays;
import java.util.Random;
import javafx.animation.AnimationTimer;
import javafx.application.Application;
import javafx.application.Platform;
import javafx.scene.Scene;
import javafx.scene.layout.HBox;
import javafx.scene.layout.VBox;
import javafx.scene.paint.Color;
import javafx.scene.shape.Rectangle;
import javafx.stage.Stage;

public class App extends Application {

    @Override
    public void start(Stage stage) {
        HBox platform = new HBox();
        VBox[] towerBoxes = new VBox[] { new VBox(), new VBox(), new VBox()};
        platform.getChildren().addAll(Arrays.asList(towerBoxes));
        Hanoi testing = new Hanoi(10);
        testing.towerBoxes = towerBoxes;
        var scene = new Scene(platform, 640, 480);
        stage.setScene(scene);
        stage.show();
        testing.solve();
    }

    public static void main(String[] args) {
        launch();
    }
}

class Tower {
    private int sp = 0;
    private Rectangle[] disks;
    
    Tower(int n) {
        disks = new Rectangle[n];
    }
    
    public void push(Rectangle entry) {
        if (sp < disks.length)
            disks[sp++] = entry;
        else
            System.err.println(this + ".push(" + entry + ") failed, stack is full");
    }
    
    public Rectangle pop() {
        if (sp > 0)
            return disks[--sp];
        else {
            System.err.println(this + ".pop() failed, stack is empty");
            return null;
        }
    }
    
    public boolean hasEntry() {
        return sp > 0;
    }
    
    @Override
    public Tower clone() {
        Tower copy = new Tower(disks.length);
        copy.sp = this.sp;
        copy.disks = this.disks.clone();
        return copy;
    }
}

class Hanoi {
    Tower src;
    Tower aux;
    Tower dest;
    int n;
    
    public VBox[] towerBoxes;
    
    public Hanoi(int n) {
        src = new Tower(n);
        aux = new Tower(n);
        dest = new Tower(n);
        
        this.n = n;
        
        for (int i = 0; i < n; i++) {
            Rectangle disk = new Rectangle(30 + 20 * i, 10);
            Color diskColor = generateRandomColor();
            disk.setFill(diskColor);
            disk.setStroke(diskColor);
            src.push(disk);
        }
    }
    
    private static Color generateRandomColor() {
        Random random = new Random();
        double red = random.nextDouble();
        double green = random.nextDouble();
        double blue = random.nextDouble();
        
        return new Color(red, green, blue, 1.0);
    }
    
    private void solve(int n, Tower src, Tower aux, Tower dest) {
        if (n < 1) {
            return;
        }
        solve(n-1, src, dest, aux);
        dest.push(src.pop());
        System.out.println(n);
        solve(n-1, aux, src, dest);
    }
    
    public void solve() {
        renderHanoi();
        timer.start();
        solve(n, src, aux, dest);
    }
    
    AnimationTimer timer = new AnimationTimer() {
        @Override
        public void handle(long now) {
          renderHanoi(); // Update UI after each frame
        }
    };

    
    private void renderHanoi() {
        for (VBox towerBox:towerBoxes)
            towerBox.getChildren().clear();
        Tower[] towersCopy = new Tower[]{src.clone(), aux.clone(), dest.clone()};
        for (int i = 0; i < 3; i++)
            while (towersCopy[i].hasEntry())
                towerBoxes[i].getChildren().add(towersCopy[i].pop());
    }
}

O problema

Há um espaçamento padrão entre meus botões de edição e exclusão no HTML. No entanto, quando adiciono um novo item de lista com JavaScript que possui exatamente a mesma estrutura e nomes de classe, não há espaçamento entre esses botões.

Comportamento desejado Para que os botões anexados tenham a mesma aparência dos botões "padrão" na marcação HTML.

Codepen

HTML

            <ul id="list">
                <li class="item">
                    <div>Milk</div>
                    <button class="edit-button">edit</button>
                    <button class="delete-button">X</button>
                </li>
                <li class="item">
                    <div>Cheerios</div>
                    <button class="edit-button">edit</button>
                    <button class="delete-button">X</button>
                </li>
                <li class="item">
                    <div>Cheese</div>
                    <button class="edit-button">edit</button>
                    <button class="delete-button">X</button>
                </li>  
            </ul>

CSS

.title {
    text-align: center;
}

.main {
    border: 1px solid black;
    width: 50%;
    margin: auto;
}

#add-item {
    border: 1px solid black;
}

.input {
    width: 100%;
    padding: 12px 20px;
    margin: 8px 0;
    display: inline-block;
    border: 1px solid #ccc;
    border-radius: 4px;
    box-sizing: border-box;
}

.label {
    margin: 10px;
}

#list {
    flex-direction: column;
    display: flex;
}

#list > li{
    list-style-type: none;
    margin: 10px auto;
}

#list div {
    margin-bottom: 10px;
    text-align: center;
}

/* #list button {
    margin: 0px 4px;
} */

JavaScript

// TODO: Grab the list
const shoppingList = document.getElementById("list")
// TODO: Grab the input field
const titleInput = document.getElementById("title")
// TODO: Grab the buttons.
const submitButton = document.getElementById("submit-item")
// const editButtons = document.querySelectorAll(".edit-button")
// const delButtons = document.querySelectorAll(".delete-button")

// TODO: Add click event to the button.
submitButton.addEventListener('click', (e) => {
    e.preventDefault()
    addItem(titleInput.value)
});

// TODO: Create a function to add item.
    // ! Requirement: Must have:
    // !   - item text
    // !   - edit button
    // !   - delete button
    // !   - input field
    // ! Requirement: Add event listeners to buttons

    // TODO: Edit button must get pass the Parent node.

function addItem(title) {
    console.log("Running addItem")
    let newItem = document.createElement("li")
    newItem.classList.add("item")

    let newTitle = document.createElement("div")
    newTitle.textContent = title

    let editBtn = document.createElement("button")
    editBtn.classList.add("edit-button")
    editBtn.innerText = "edit"

    let delBtn = document.createElement("button")
    delBtn.classList.add("delete-button")
    delBtn.innerText = "X"

    editBtn.addEventListener('click', (e) => {
        console.log("Pressed the edit button", e)
        editItem(e.target.parentElement)
    });

    newItem.appendChild(newTitle)
    newItem.appendChild(editBtn)
    newItem.appendChild(delBtn)
    shoppingList.appendChild(newItem)
}


// TODO: Create a function to edit item.
    // ! Requirement: Parent Node (Element) parameter

    // TODO: Remove the Edit, Delete buttons.
    // TODO: Grab text content of the div and assign to variable.
    // TODO: Add an input element to the parent node.
    // TODO: Set input's value to the variable with the text content.
    // TODO: Add the save button.

function editItem(listItem) {
    let title;
    listItem.childNodes.forEach(element => {
        console.log(element.tagName)
        if(element.tagName === "DIV") {
            title = element.innerText
        }
    });

    listItem.innerHTML = ""

    let editInput = document.createElement("input")
    editInput.value = title

    let saveBtn = document.createElement("button")
    saveBtn.classList.add("save-button")
    saveBtn.innerText = "save"

    listItem.append(editInput, saveBtn)

    saveBtn.addEventListener('click', (e) => {
        saveItem(e.target.parentNode)
    });
}

// TODO: Create a function to save item.
    // ! Requirement: Parent Node (Element) parameter
    // TODO: Get the value of the input field and assign to variable
    // TODO: Remove the input and save button.
    // TODO: Create the div, edit, and delete buttons.
    // TODO: Set the div's text content to the variable with the input's value.
    // TODO: Add all those elements to the parent element.

function saveItem(listItem) {
    let titleEdit;

    listItem.childNodes.forEach(element => {
        if(element.tagName === "INPUT") {
            titleEdit = element.value
        }
    });

    listItem.innerHTML = "";

    let changedTitle = document.createElement("div");
    changedTitle.textContent = titleEdit;

    let editBtn = document.createElement("button");
    editBtn.classList.add("edit-button");
    editBtn.innerText = "edit";

    let delBtn = document.createElement("button");
    delBtn.classList.add("delete-button");
    delBtn.innerText = "X";

    listItem.appendChild(changedTitle);
    listItem.appendChild(editBtn);
    listItem.appendChild(delBtn);
}

// TODO: Create a function to delete item.
    // ! Requirement: Parent Node (Element) paramter
    // I believe you can figure this one out yourself. <3 :) 

O que eu tentei

• No entanto, adicionando estilo aos botões, ainda houve espaço reduzido entre os botões no item da lista anexado. (Eu esperava que talvez resolvesse o problema se os botões tivessem estilo aplicado, seria o espaçamento correto para todos eles. Os elementos HTML tinham 4px de espaçamento, mas parece que o elemento anexado tem espaçamento de 2px.)
• Verificou vários navegadores para ver se o navegador estava sendo renderizado de forma diferente, no entanto, o erro de espaçamento persistiu em todos os navegadores. (Eu esperava ver uma versão correta em um dos navegadores para identificar se era um problema de renderização entre navegadores.)
• Tentei uma redefinição de CSS, o resultado foi o espaçamento padrão entre os botões HTML e nenhum espaçamento entre os botões anexados. (Eu esperava que uma redefinição de CSS removesse todo o espaçamento entre os botões, mas parece que teve o efeito padrão mostrado no codepen.)
• Tentei colocar meu código em um ambiente CodePen e ainda tive o mesmo problema. (Eu esperava que funcionasse se houvesse um problema com meu ambiente local.)
• Verifiquei o código para talvez um espaço de carro/retorno e não encontrei nada. (Eu esperava que um espaço oculto pudesse ser a causa e removê-lo produziria os resultados desejados.)
• Até verifiquei com meu instrutor e eles também não têm certeza. (Eles me disseram para remover apenas os itens da lista padrão como uma solução alternativa, mas estou postando porque estou genuinamente curioso para saber por que isso está acontecendo.)

Artigos do StackOverflow que analisei (tentei vinculá-los, mas dizia que esses links faziam minha pergunta parecer "Spam" - então, aqui estão os títulos.)

Por que os estilos CSS iniciais não são visíveis no campo de estilo do elemento DOM?

Isso está falando sobre um problema ao acessar a propriedade CSS de um estilo, em vez de acessar as propriedades CSS totalmente renderizadas. Isso não é realmente aplicável, pois não há estilos por padrão neste exemplo.

Elemento anexado com estilos ausentes

Os estilos não faltam, eles são aplicados, mas o mesmo estilo é aplicado de forma diferente entre os elementos anexados.

Remova espaços em branco entre botões em HTML CSS

Fiz uma redefinição de CSS e o problema ainda estava acontecendo. Além disso, este é um espaçamento horizontal e não vertical.

Posso usar um DIV dentro de um item de lista?

Verificando se a estrutura HTML era válida e as especificações HTML dizem que posso ter divs e outros elementos de nível de bloco dentro do li.

O conteúdo anexado não obtém o efeito CSS adequado

Essa pessoa teve um problema em que o div foi anexado dentro do elemento UL e estava causando problemas. Este não é o meu problema.

Anexando elementos ao DOM com espaçamento de recuo

Esta questão específica estava tendo problemas com a estrutura HTML do DIV anexado que não estava no formato correto. Eu também não estou tendo esse problema. Minha estrutura HTML parece ser exatamente a mesma nas Ferramentas de Desenvolvimento.

Erro estranho ao anexar elementos em JavaScript

Este problema específico está encontrando um erro de tipo. Não há erros no console. Parece ser um bug estranho de formatação/CSS.

Nenhum desses artigos parecia aplicar-se a esta questão específica. Não tenho certeza se isso é um bug ou não, mas, considerando que se trata principalmente de um estilo padrão, persistente em todos os navegadores e persiste mesmo quando estilos são adicionados. Estou perdido.